You are on page 1of 67

PROGRAMACIÓN FUNCIONAL LISP

Concepto Matemático de Función
Cubo(x) = x3 Cubo: R

R

Dominio : Codominio (Intervalo)

Asignación y Funciones
Cubo(x) = x3 En los lenguajes imperativos la variable x: 

Es una ubicación en memoria x = x + 1, significa actualizar el estado del programa añadiendo 1 al valor almacenado en la celda de memoria llamada x y después almacenar la suma en dicha celda l-value = r-value  

No existe el concepto de estado ni de valor almacenado   .Asignación y Funciones Cubo(x) = x3 En matemáticas la variable x:  Es el valor de una expresión real Es inmutable.

Asignación y Funciones  Programación funcional pura concepto matemático de función  Lenguajes funcionales Impuros ( Mantienen algún tipo de asignación ) Transparencia Referencial El valor de una función depende SÓLO de sus parámetros Cálculo Lambda   .

por lo que se acerca más al software que al hardware Principal influencia de los lenguajes de programación funcionales (especialmente de LISP) .Cálculo Lambda       Alonzo Church & Stephen Cole Kleene ( 1930 s ) Sistema formal para investigar definición y aplicación de funciones y recursión Permite definir lo que es una función computable e implementar cualquiera de ellas Equivalente a las Máquinas de Turing Enfatiza el uso de reglas de transformación más allá de la máquina que las implementa.

Cálculo Lambda
Expresiones lambda: <expr> ::= <identificador> 

<expr> ::= ( <identificador> . <expr>) 

Denominada abstracción

<expr> ::= (<expr> <expr>) 

Denominada aplicación (a un argumento)

Las dos primeras generan funciones.

Cálculo Lambda
Ejemplos: 

x ó (x) ( x.x)

identificador Abstracción Aplicación + abstracción  

(( x.x)( y.y)) ( x.(zx)) ( ( 

Abstracción + aplicación Expresión compleja 

y.( ( x.xyz)a ) )b )

Cálculo Lambda
Definiciones: 

En la expresión lambda ( x.M), siendo M, a su vez, cualquier expresión lambda, se dice que el identificador x está unido en la subexpresión M. Cualquier identificador que no esté unido se dice que es libre.

Reglas para la determinación de variables libres: ( x es un identificador y M, N son expresiones lambda ) 
 

libres( x ) = x libres( MN ) = libres( M ) Š libres( N ) libres( ( x.M) ) = libres( M ) { x }

E[V/W] ) en E cuando  si W no está libre en E y W no está unida por una remplaza a V.E) == ( W. que: ( ( x.Cálculo Lambda Conversión E:  Los nombres de las variables no son importantes.y) Si V y W son variables.x) == ( y. entonces: ( V.x)) x ) == ( ( y. Esto nos dice. E es una expresión lambda y E[V/W] significa la expresión E. con el remplazo de todas las ocurrencias libres de V por W.( x.x)) y ) . por ejemplo.( x. ( x.

E) E ) se denomina forma normal. esto es. que: ( ( y. Esto nos dice.E) E ) == E[V/E ] si todas las ocurrencias libres en E permanecen libres en E[V/E ]. si V es una variable y E.xyz)a ) )b )  ( ( y. entonces: ( ( V.( ( x. que no tiene subexpresiones de tipo ( ( V.ayz)b ) ( abz ) Una expresión que ya no permite reducciones F. . esto es. por ejemplo.Cálculo Lambda Reducción F:  Expresa la idea de la aplicación de una función. E son expresiones lambda.

resulta de la reducción F: ( ( x . resulta de la reducción F: ( ( x . y ) = x .x-y)) Aplicándola a un cierto valor. x + 2 )3 ) ( 3 + 2 ) ( 5 ) Una función de 2 variables en cálculo lambda se expresa como una función de 1 argumento que devuelve una función de 1 argumento. la función agrega dos f(x) = x + 2.Cálculo Lambda El significado de las expresiones lambda consiste en la evaluación de las funciones que las componen:  Por ejemplo. y + 2 ) según la conversión E Aplicándola a un cierto valor. x . en cálculo lambda se expresa: ( x . la función de 2 variables f( x. Por ejemplo. x .2 )7 ) ( 7    2) (5) . ( y .( y. x + 2 ) ó ( y .y )2 )7 ) ( ( x .y: ( x.

se reduciría a ( 25 ). Estableciendo ciertas restricciones al cálculo lambda se obtiene el cálculo combinacional / de predicados. que definen conjuntos infinitos. son iguales. reducidas a su forma normal. A pesar de lo anterior. Ejemplo: Funciones que implícitamente se definen recursivamente o. sin mayor reducción. . esto es. si dos expresiones lambda. se dice que las formas originales (y las normales) son equivalentes. x * x )5 ) (5 * 5). Por tanto ( ( x .Cálculo Lambda     La forma normal de una expresión lambda se utiliza para determinar la relación de equivalencia entre expresiones. Sólo en el cálculo lambda aplicado. no a toda expresión lambda le corresponde una forma normal. como los lenguajes de programación funcionales. El cálculo lambda puro desarrollado por Church no ofrece interpretación de símbolos.

Interactuando con LISP .

abc . etc. (128 128). A diferencia de otros lenguajes. ). ( S . 1. )  String ( Adiós . Lisp .Symbolic )  Átomos  Numéricos: Enteros o de punto flotante ( -25.75. accesados con el nombre del arreglo y uno o varios subíndices ( ( (a b c)(1 2 3) ). utilizados mayormente como variables. etc. etc. *. +. pueden iniciar con dígitos. símbolos u otras expresiones S. etc.Componentes de los Lenguajes Funcionales  Expresiones S: Unidades sintácticas que representan datos y sentencias de programa en Lisp. ) . caracteres de puntuación y aún caracteres especiales.  Carácter ( #\a. Lisp no es sensible a minúsculas y mayúsculas. MANZANA. #\b. etc. )  Símbolos o átomos literales : Identificadores en otros lenguajes. #\{. )  Arreglo: Colección de enteros. caracteres. ( X. P1.

) Macros: Lista cuyo primer componente es el nombre de una macro. La lista vacía o de cero componentes se escribe () . También se utiliza en forma equivalente un SÍMBOLO especial para denotar esta lista: NIL. 1+. etc. separadas por espacios en blanco y encerradas entre paréntesis. Sirven como envolturas para crear nuevas formas funcionales.    Funcionales: Lista cuyo primer elemento es el nombre de una función y los restantes son los parámetros de la misma ( +. Especiales: Formas que controlan la ejecución de un programa en Lisp ( IF.Componentes de los Lenguajes Funcionales  Compuestas  Listas: Consiste de cero o más expresiones S (que pueden ser atómicas o compuestas a su vez). cdr. la cual se expande como llamada a una forma funcional. COND. DOLIST. etc.  Formas: Instrucciones. ) . car.

por eso tal objeto se le denomina un cons. Contents of Address of Register Macro del ensamblador de la computadora IBM 704 en la que por primera vez se implementó Lisp. de otras dos proporcionadas. Contents of Decrement of Register Otra macro del ensamblador citado.  (cons expS1 expS2)  (car expS) ó (first expS)  CDR Cúder : Devuelve la otra mitad que compone a la expresión proporcionada (siempre una lista). También se proporciona el nombre FIRST para esta misma funcionalidad. CAR: Devuelve la primera expresión S que compone a la expresión proporcionada.Algunas Funciones Elementales Expresiones  S = componente1 + componente2 + + componenteN Manipulación de la estructura de una lista  CONS: Forma una nueva expresión S compuesta. También se proporciona el nombre REST para esta misma funcionalidad. CONStruye la nueva expresión. .  (cdr expS) ó (rest expS) CAR y CDR devuelven NIL si su argumento es NIL.

TENTH y  . THIRD. C + A (por cada car) + D (por cada cdr) + R  Funciones equivalentes: FIRST. SECOND. Combinaciones de CAR y CDR:  (car (car x)) (caar x) (car (cdr x)) (cadr x) Segunda expresión S de x (cdr (car x)) (cdar x) (cdr (cdr x)) (cddr x) (car (cdr (cdr x))) (caddr x) Tercera expresión S permutaciones hasta de 4 A s y D s. NTH.Algunas Funciones Elementales  No siempre CAR + CDR deshacen lo hecho por CONS. (nth n lista) .

en forma recursiva si es necesario.Algunas Funciones Elementales  APPEND: Devuelve una nueva lista. (append lista1 lista2 listak)  LIST: Devuelve la lista de los k valores resultado de la evaluación de las k expresiones S proporcionadas como parámetros. los parámetros de la misma. resultado de la concatenación de las listas dadas como parámetros. el intérprete de Lisp evalúa primeramente.  (list expS1 expS2 expSk)  Evaluación de Formas Funcionales Para evaluar una forma funcional. . por lo que se puede utilizar QUOTE para evitar tal comportamiento en donde así sea requerido. o su forma abreviada consistente en el carácter .

en tal caso. Permite que los símbolos respectivos a cada asignación sean expresiones. expSoSimbolok expSk) . se evalúan éstas antes del procesamiento..  (set expS1 expS2)  SETQ SETQUOTE : Evalúa cada expresión S recibida como parámetro y el valor resultante se lo asigna al símbolo respectivo. el valor obtenido de la segunda. exceptuando que permite la asignación a elementos de arreglos. simbolok expSk)  SETF: Equivalente a SETQ. Forma Especial.  (setf expSoSimbolo1 expS1 . Función..Algunas Funciones Elementales  Asignación  SET: Evalúa ambas expresiones S que recibe como parámetros y le asigna al valor global de la primera expresión (por lo que ésta debe ser un símbolo). estructuras y tipos más complejos en los que SETQ falla. Macro..  (setq simbolo1 expS1 ..

Manejo de Memoria     Celdas   2 o 3 palabras (de memoria) de la máquina Microcomputadoras   4 bytes Macrocomputadoras   Hasta 8 bytes (64 bits) por celda Celda   2 apuntadores  Celda cons: Apuntador al CAR + apuntador al CDR Apuntador al CAR Apuntador al CDR .

Más Sobre Expresiones .S Formalmente: 1. . v. S2. caracter. . Sk ) es una expresión S y se denomina lista de veces de las reglas 1. Cualquier átomo es una expresión S. S2. entonces (S1.S 4. Sk son expresiones S. con k u 0. cualquier número. Si S1. Solamente un objeto formado por la aplicación de un número finito . entonces la expresión ( X . 2 y 3 es una expresión . Y ) es una S y se denomina par punteado ( dotted pair ) 2. símbolo. gr.. string o arreglo es una expresión S expresión S. Si X y Y son expresiones 3.

(C.D)) Dotted List: ( (A.B).D) ) A B C ( A . ( B .B) (C. ( C .B) A B C D ((A.Manejo de Memoria A A B Estructura de Datos (A. NIL ) ) ) Como lista: ( A B C ) .

Apuntador implícito a NIL. CDR-NEXT: La siguiente celda en memoria contiene el siguiente elemento de la lista (el siguiente CAR). deben copiar primero el CONS en esa celda y colocar un apuntador de redirección a la nueva celda donde está la copia creada. CDR-NIL: Última celda de la lista.Coding CDR-NEXT CDR-NEXT CDR Code ( 2 bits ): Elem1 CDR-NEXT Elem2 CDR-NEXT CDR-NORMAL: Primera mitad de celda normal .Lx Cons1 .Lx CDR-NORMAL Elem2 . Las funciones de Lisp que remplazan el apuntador al CDR directamente.Lx CDR-NIL . Elem3 CDR-NEXT Elem4 Elem5 CDR-NORMAL CDR-NIL CDR-NORMAL Elem1 .CDR .

Unidad de Manejo de Memoria Funciones CORE READ. FUNCIONES ARITMETICAS Y FUNCIONES FUNCIONES PREDICADOS FUNCIONES Lenguaje de bajo nivel Velocidad Librería de Funciones Implementadas en base a las Funciones del núcleo IMPLEMENTACIÓN DE LISP . NULL. ATOM. APPLY. PRINT. CDR. READ. CONS. CAR. EVAL.

Recolección de Basura Memoria Apuntador freelist Memoria Apuntador freelist Recolección De Basura . . .

. . . . .Recolección de Basura TABLA DE SIMBOLOS S1 S2 S3 S4 S5 S6 S7 S8 S9 S10 S11 . Marcar y Barrer Apuntador freelist . 1 Bit Marcar .

. Remplazar Referencias . Buscar Celdas Ocupadas Apuntador de Redirección Referencia (CDR S1) . .Recolección de Basura Datos Copiados Buscar Celdas Libres Compactar Apuntador freelist . . Copiar Datos .

Recolección de Basura Compactar  Dada la lentitud del proceso. pero de menor grado de interrupción de trabajo. se utilizan algoritmos incrementales de mucha mayor complejidad. * .

 Explícitamente el símbolo T significa TRUE. gr.Predicados y Formas Condicionales Predicados: Funciones que devuelven valores que se interpretan como booleanos ( TRUE / FALSE ). Función.: (< 3 5) TRUE (> 3 5) NIL Combinación de predicados  (and expS1 expS2 expSn) Conjunción lógica.  (not expS) ó (null expS) Negación lógica. v.  Evalúan en corto circuito.  (or expS1 expS2 expSn) Disyunción lógica.  Cualquier valor que no sea explícitamente NIL se toma como TRUE. Macro. Macro. .

evenp. >. >= y /= : Comparación   . vectorp y characterp: Probar si es string. <=. arrayp.Predicados y Formas Condicionales       (atom expS) T si expS es un átomo (null expS) T si expS es NIL (symbolp expS) T si expS es un símbolo (listp expS) T si expS es una lista (consp expS) T si expS es un objeto cons (como listp pero excluye a NIL) (numberp expS) T si expS es un átomo numérico Pruebas más específicas del tipo numérico:  integerp. floatp. plusp y minusp stringp. oddp. impar y mayor o menor a cero:  zerop. = (un solo caracter). rationalp y complexp Probar si es cero. par. arreglo. vector (arreglo de una sola dimensión) o si es carácter.

números u otros objetos. Para comparar símbolos (eql expS1 expS2) T si expS1 y expS2 son números del mismo tipo y valor. gr. si son objetos representando el mismo caracter o. Para comparar átomos  . No se puede usar para comparar listas. (< 2 3 5 6 9) T (< 2 3 5 6 6) NIL (< 6 6 ) es NIL  Pruebas de igualdad:  (eq expS1 expS2) T si expS1 y expS2 son el mismo objeto Lisp. aplicándose sucesivamente a cada par de argumentos adyacentes. si la función eq aplicada a ellas devuelve T . Common Lisp compara si ambos apuntadores a las expresiones son iguales. v.Predicados y Formas Condicionales Todos los predicados pueden recibir uno o más argumentos.

incluyendo sus expresiones . normalmente. EQUAL no compara los elementos individuales de arreglos. Los objetos son equivalentes.Predicados y Formas Condicionales  (equal expS1 expS2) T si expS1 y expS2 evalúan a objetos Lisp equivalentes. la instrucción toma la forma (member elemento lista :test # EQUAL)  . excepto para strings y vectores bit. Sin embargo.S internas  Un predicado especial que aplica estas funciones es:  (member elemento lista) T si elemento es miembro de lista (sólo en el nivel superior de ella). si sus representaciones impresas son las mismas. la cual no trabaja correctamente en objetos CONS. La función de comparación por defecto es EQL. Para utilizar EQUAL. EQUAL es sensible a mayúsculas y minúsculas (equalp expS1 expS2) T si expS1 y expS2 evalúan a objetos Lisp equivalentes.

Predicados y Formas Condicionales (if expS-Prueba expS-NotNull expS-IfNull) Evalúa expS-Prueba. si el resultado no es NIL (true). es el resultado de toda la expresión cond. gr. v. true). esto es. (if (= x 21) (print ´BlackJack!) ) (setq x (if z ´Lista-No-Vacía´Lista-Vacía) )  (cond (c1 e11 e1K1) (c2 e21 e2K2) (c1 en1 enKn) ) Evalúa consecutivamente las expresiones de condición ci (en orden de aparición). se evalúan todas las expresiones ei1 eik correspondientes y. de lo contrario se evalúa expS-IfNull (ésta última es opcional) v. gr. Las expresiones son mutuamente excluyentes. (setq x ( cond ( (atom milista) ´Atomo) ( (listp milista) ´Lista) ( (t ´Desconocido) )) . si alguna de ellas resulta diferente de NIL (o su sinónimo null. se evalúa expS-notNull. el último valor obtenido. se entra a una sola rama del cond. Caso default  .

( defun cubo ( x ) Calcula el cubo de un valor ( * x x x ) ) Después de que la definición se ha evaluado. se puede utilizar. gr. (describe ´cubo) Calcula el cubo de un valor . v. v.Definición de Funciones  (defun nombre parámetros string-descripción cuerpo) Cuando esta forma especial se evalúa. gr. gr. pero provee información que se puede accesar a través de la función interconstruida DESCRIBE. el sistema intérprete de Lisp introduce una definición de función bajo el nombre dado. no afecta la ejecución de la misma. v. El cuerpo de la función consiste de una o más formas que expresan el valor a devolver con base en los argumentos proporcionados. (cubo 7) 343   string-descripción se utiliza para documentar la función.

 Recursión: Véase Recursión.Recursión  Recursión: Cualquier cosa o ente . Números Complejos Números Reales Números Enteros .Definición de Funciones . definido en términos de sí mismo.

 v. gr.Recursión  Función Recursiva: Función aplicada a un objeto complejo." ( cond ( (null l1) l2 ) ( t ( cons (first l1) (anexar (rest l1) l2) ) ) ))  ." ( cond ( (null lista) 0 ) ( t ( 1+ (longitud (rest lista)) ) ) )) v. definida como la combinación de resultados de aplicar la misma función a componentes del objeto complejo.Definición de Funciones . gr. (defun longitud ( lista ) "Devuelve el número de elementos en el nivel superior de LISTA. (defun anexar ( l1 l2 ) "Devuelve la concatenación de L2 a L1.

n 1) (* acumula n) ) ) ) (iterar n 1) ) . gr. (defun factorial ( n ) "Devuelve el factorial de N." (if (<= n 1) acumula (iterar (.    v.Definición de Funciones  Recursión de Cola Función con Recursión de Cola (Tail Recursion): Función recursiva cuya última operación consiste en la ejecución de la llamada a sí misma. Normalmente requiere el uso de una variable acumulador . Scheme fuerza la implementación de este tipo de recursión. Su importancia se debe a que es relativamente fácil optimizarse hacia un ciclo de repetición. (defun iterar (n acumula) "Devuelve el factorial de N utilizando como acumulador ACUMULA.

Trace: ITERAR ==> 120 1. Trace: 2. Trace: 4. Trace: 4. Esto le permite a un intérprete o compilador reorganizar la ejecución de: 1. Trace: 1. Trace: 3. Trace: 5. Trace: 6. Trace: (FACTORIAL '5) (ITERAR '5 '1) (ITERAR '4 '5) (ITERAR '3 '20) (ITERAR '2 '60) (ITERAR '1 '120) 6. Trace: (ITERAR '5 '1) Remplazar parámetros con ('4 '5) saltar a ITERAR Remplazar parámetros con ('3 '20) re-ITERAR Remplazar parámetros con ( 2 60) re-ITERAR Remplazar parámetros con ( 1 120) re-ITERAR 6. Trace: 5. Trace: 3. Trace: 2.Definición de Funciones Recursión de Cola La función interna ITERAR se llama a sí misma al final de su definición. Trace: (FACTORIAL '5) 2. Trace: FACTORIAL ==> 120 120 . Trace: 120 ITERAR ==> 120 ITERAR ==> 120 ITERAR ==> 120 ITERAR ==> 120 ITERAR ==> 120 FACTORIAL ==> 120 A la forma más eficiente en espacio (y tiempo): 1.

Esto es: *mivariable*. etc. el compilador emitirá un error si se intenta modificar su valor  Por convención. *N*.Variables Globales y Locales  Cada símbolo puede tener un valor global y uno local (en un momento dado)  Formas de establecer el valor global:  Macro SETF fuera del ámbito local del símbolo  Función SET (siempre accede al valor global)  Función SETQ fuera del ámbito local del símbolo  (defvar nombre valor-inicial string-descripcion)  Definición de variables globales:  (defparameter nombre valor-inicial string-descripcion) Un valor que se espera cambie durante la ejecución del programa  (defconstant nombre valor-constante string-descripcion) Se espera no cambie durante una ejecución del programa (pero sí entre varias) Inmutable. . el nombre de las variables globales se coloca entre * .

4142135 Raíz cuadrada de 2 )  Formas de acceder al valor global:  (symbol-value ´nombre-variable) Siempre devuelve el valor global del símbolo. de lo contrario devolverá su valor global. asumiendo que tenga uno  Evaluándose el símbolo Esta evaluación devuelve el valor local (léxico) más interno del símbolo (si existe). no puede tener string-descripción (defvar *mivariable* 5) (defvar *mivariable* 5 Mi variable global ) (defparameter *N* 10 Número de iteraciones ) (defconstant *raiz2* 1. se indicará un error de símbolo no ligado (a un valor) . Si ninguno de los dos existe. Sin valor.Variables Globales y Locales (defvar *mivariable*) .

. . Devuelve 0 del LET. x local = 0. las variables locales se eliminan de la pila  El ámbito de las variables definidas por esta forma especial se concreta exclusivamente al cuerpo de la misma (setf x 1) (let ( (x 5) (y (1+ x)) ) (print (+ x y)) (setf x 0) ) (print x) . Variable local y = 2 (x local no existe aún). Variable local x = 5. Inclusive para funciones recursivas. . . Imprime x global = 1. . Valor global de x es 1. vardefi (símbolo) y/o par (símbolo expS-valor-inicial) expSj Cuerpo de la forma especial LET  (let (vardef1 vardef2 vardefk) expS1 expS2 expSn)  Finalizado el LET. . Suma x local con y local.  Para crear ambientes locales de variables se utilizan las formas especiales LET y LET*.Variables Globales y Locales  Variables Locales:  Los parámetros de una función son locales a la misma. imprime 7. .

La forma LET* permite escribir código eficiente y fácil de leer. por lo que la suma de x . cuando normalmente se requieren tres (* x x x x). con x = 5. Por ejemplo:  (let* ( (x 5) (x-cuadrada (* x x)) (x-cuarta (* x-cuadrada x-cuadrada)) (f-de-x (+ (* 3 x-cuarta) (* 5 x-cuadrada) 7)) ) (print (* f-de-x 2)) ) Esta función calcula f(x) = 3x4+5x2+7.Variables Globales y Locales  La forma LET* se diferencia de LET. y imprimiría 11. exclusivamente. Note que sólo dos multiplicaciones binarias se utilizan para calcular x4. Finalmente multiplica por dos f(x) y devuelve un resultado de 4014. En el ejemplo anterior y recibiría el valor 6 y no 2. . en que el inicio del ámbito de las variables locales comienza una vez declaradas éstas. Se puede aprovechar la inicialización de la forma LET* para calcular funciones más complejas de la primera variable declarada.

el resultado de evaluar la expresión result (si existe) se devuelve. La evaluación se repite indefinidamente o hasta que sea interrumpida por una instrucción RETURN. desde 0 al entero calculado menos 1.Ciclos de Repetición  (loop expS1 expS2 expSk) Evalúa repetidamente y en secuencia las expSi. (loop (setf x (read)) (if (eql x ´exit) (return)) (setf x (cons x x)) (print x) )  (dotimes (var count resultado) expS1 expS2 expSk ) Evalúa la parte expresión count (que debe producir un número entero) y repite la evaluación de las expSi una vez por cada valor (asignado a la variable var). Al finalizar. (let (potencias-de-2 potencias-de-3) (dotimes (i 10 (list potencias-de-2 potencias-de-3)) (setf potencias-de-2 (append potencias-de-2 (list (expt i 2)))) (setf potencias-de-3 (append potencias-de-3 (list (expt i 3)))) ) (print potencias-de-2) (print potencias-de-3) ) .

En cada repetición del ciclo se realizan las operaciones: (setf var (car lista-valores)) y (setf listavalores (cdr lista-valores)) (let ((x nil)) (dolist (stack ´(a b c) x) (push stack x) ) (print x) ) .Ciclos de Repetición  (dolist (var lista-valores resultado) expS1 expS2 expSk ) Evalúa las expSi una vez por cada asignación a var de un elemento de los valores de lista-valores. Al finalizar. el resultado de evaluar la expresión result (si existe) se devuelve.

(setf max '(if (> arg1 arg2) arg1 arg2) ) (print Dato1? ) (setf arg1 (read)) (print Dato2? ) (setf arg2 (read)) (setf x (eval max)) . Por ejemplo. Evaluar max en tiempo de ejecución . en matemáticas las funciones de derivación y/o integración son de orden superior.  (eval expS) El intérprete de Lisp evalúa expS y.Funciones de Orden Superior  Funciones que pueden tener como argumentos otras funciones. y que también pueden devolver funciones como resultado. Esto es útil para evaluar formas que son construidas en tiempo de ejecución. realiza una evaluación extra. posteriormente.

a los argumentos ai. El número de argumentos dados a funcall debe coincidir con el número de parámetros que recibe la función a invocar indirectamente.Funciones de Orden Superior  (funcall nombre-función a1 a2 ak) Aplica el valor de nombre-función (un símbolo al que se le ha asignado el nombre de una función). (print "Dato1? " ) (setf arg1 (read)) (print "Dato2? " ) (setf arg2 (read)) (print "Qué operación aplico (+ ó -)? " ) (setf f (read)) (setf x (funcall f arg1 arg2))    Muy útil cuando no se conoce en tiempo de compilación la función a aplicar. . La función a ejecutar NO debe ser una forma especial o de macro.

 nombre-función se aplica a la lista obtenida de la concatenación de los argumentos Ak (si existen) y lista-argumentos.Funciones de Orden Superior  (apply nombre-función A1 A2 Ak lista-argumentos) Idéntica a funcall. (print "Lista de argumentos? " ) (setf arg1 (read)) (print "Qué operación aplico (+ ó -)? " ) (setf f (read)) (setf x (apply f arg1))   El último argumento dado a apply. pero se utiliza cuando el número de argumentos no se conoce anticipadamente. Igual que para funcall. la función a ejecutar NO debe ser una forma especial o de macro. En tal caso se debe utilizar eval. . siempre debe ser una lista.

existe una abreviatura para FUNCTION. (print "Lista de argumentos? " ) (setf arg1 (read)) (setf x (apply (function +) arg1))  Debido a su uso frecuente. (print "Lista de argumentos? " ) (setf arg1 (read)) (setf x (apply #'+ arg1)) . igual que para QUOTE y '.Funciones de Orden Superior  nombre-función también puede ser un objeto funcional devuelto por una llamada a la función function. Esta es #'.

la forma especial FUNCTION sirve para evitar que la expresión LAMBDA sea evaluada. Proporcionan idea de localidad . (lambda lista-argumentos cuerpo) (lambda (x y) (+ (* x x) (* 2 y))) La función f(x) = x2 + 2y  Las expresiones lambda se utilizan más comúnmente como argumentos de APPLY. . haciendo más fácil entender el código. ya que la función se encuentra donde se utiliza. (print "Dato? " ) (setf arg1 (read)) (setf x (apply (function (lambda (y) (* y y y))) (list arg1)))  En el ejemplo anterior.Expresiones LAMBDA    Especifican funciones en un programa de Lisp. sin la necesidad de darles o llamarlas por nombre.

" (mapcar #'(lambda (palabra) (cond ((eql palabra 'es) 'fue) ((eql palabra 'son) 'fueron) (t palabra) ) ) presente) ) (print (pasado '(Yuridia y Silvia son mexicanas pero Michael Jackson no lo es)))  MAPCAR aplica una función a cada uno de los elementos de la lista que se le proporciona. Si hay k listas de argumentos.. La longitud de la lista de resultados es igual a la longitud de la lista de argumentos más corta.Funciones de Orden Superior    (mapcar nombre-función lista-args1 lista-args2 lista-argsk) Aplica nombrefunción sucesivamente a los CARs de las lista-argsi y devuelve una lista con los resultados obtenidos. Otro ejemplo (defun pasado( presente ) "Devuelve el pasado participio de PRESENTE. (setf x (mapcar #'1+ '(1 2 3))) .. entonces nombre-función debe ser una función de k argumentos. .

(print exp-S stream) Imprime el valor de exp-S. Las secuencias de escape se imprimen en compatibilidad con READ. el valor de exp-S al flujo de salida stream. . (terpri) (princ "Primer argumento? ") (setf arg1 (read)) (terpri) (princ "Segundo argumento? ") (setf arg2 (read)) (terpri) (prin1 (list arg1 arg2)) (terpri) (princ (list arg1 arg2))   (princ exp-S stream) Idéntica a PRIN1.Entrada / Salida    (read stream) Obtiene una expresión S del flujo de entrada stream y lo devuelve. con la diferencia que las secuencias de escape no son impresas. se hará a la salida estándar. pero iniciando en una nueva línea. (terpri stream) Imprime la combinación retorno de carro + salto de línea al flujo de salida stream. si se omite. si se omite. a la salida estándar. se lee de la entrada estándar. (prin1 exp-S stream) Imprime (sin iniciar una línea). Al igual que PRINT. Si se omite stream. lo hace a la salida estándar). al flujo de salida stream (si se omite. utilizando PRIN1.

pero los caracteres de escape no se imprimen Dato Entero (n Ancho total.~%" 1 'pi pi "una constante") . c Caracter de relleno) Flotante (n Ancho total. se escribe a la salida estándar y se devuelve NIL. d Dígitos decimales) Imprime una ~ S a imprimir (una por cada directiva de string-formato:  ~  ~%  ~S  ~A  ~n.5F y es ~A. Si stream es T. El valor de ~S es ~7. se devuelve un string conteniendo la información con formato. Si stream es NIL. Indica una directiva de formato Imprimir retorno de carro + avance de línea Imprimir una expresión S (la correspondiente expSi) Igual.Entrada / Salida  (format stream string-formato expS1 expS2 expSk) Escribe una salida con formato al stream indicado.cD  ~n.dF  ~~ expSi Las expresiones impresión) (format t "~%Elemento ~D.

inicializándolo con: . caracteres. datos enteros.  Por convención.). los índices inician en 0. Crea un arreglo bidimensional de 3 por 2 . que se accesan a través del nombre del arreglo y uno o más índices enteros. etc. (make-array (dim1 dim2 dimk) opciones) Opciones:     :ELEMENT-TYPE Tipo específico de datos en el arreglo :INITIAL-ELEMENT Valor inicial de los datos en el arreglo :INITIAL-CONTENTS Contenidos iniciales del arreglo (make-array (3 2) :element-type integer :initial-contents ((a b)(2 3)(c 5)) ) . 23 . Tiene el mismo efecto . c5 ( setf miarreglo #2a((a b)(2 3)(c 5)) ) .Estructuras Complejas Arreglos Colección de expresiones S (especialmente de tipo atómico como números. símbolos. ab .

Estructuras Complejas  Especificar el tipo de los elementos a guardar en el arreglo (:ELEMENT-TYPE). Tiene el mismo efecto  Abreviaciones:    Arreglo unidimensional o vector: #( expS1 expS2 expSk) Bidimensional (de rango 2): #2A( Lista1 Lista2 Listak). Crea un arreglo unidimensional de 5 . permite al compilador almacenar eficientemente los datos y crear código de acceso a ellos optimizado. según sea necesario para especificar todos los elementos del arreglo. ( setf x (make-array (5) :initial-element x) ) . donde cada Li contendrá listas. ( La A es de arreglo ) n dimensional: #nA( Lista1 Lista2 Listak). donde cada Li es una lista de valores iniciales no enmarcados (unquoted). . todos inicializados a X ( setf x #(x x x x x) ) . etc. sublistas. para cada fila del arreglo. elementos..

2a. .  (array-dimensions arreglo) Devuelve una lista con las dimensiones del arreglo.  (array-total-size arreglo) Número de elementos.  (array-element-type arreglo) Tipo de elementos ó T (true). columna del arreglo miarreglo (setf (aref miarreglo 2 1) 10)  Obtener atributos de un arreglo:  (array-rank arreglo) Número de dimensiones. si el tipo no está restringido. . .  (array-in-bounds-p arreglo indice1 indice2 indicek) Devuelve T si el elemento referenciado se encuentra dentro de los límites del arreglo. fila.Estructuras Complejas  (aref nombre-arreglo indice1 indice2 indicek) Permite el acceso al elemento en el arreglo especificado por los indicei. Almacena 10 en la 3a.

~D]? " i j) (setf (aref matriz i j) (read)) ) ) (dotimes (i m NIL) .*** Calcular la matriz transpuesta (dotimes (j n NIL) (setf (aref trans j i) (aref matriz i j)) ) ) . ~S~%Matriz Transpuesta: ~S" matriz trans) .*** Solicitar dimensiones (setf matriz (make-array (list m n) :element-type 'integer)) (setf trans (make-array (list n m) :element-type 'integer)) .Estructuras Complejas (terpri) (princ "Filas? ") (setf m (read)) (princ "Columnas? ") (setf n (read)) .*** Inicializar arreglos (print "Introduzca los elementos del arreglo (sólo enteros)") (terpri) (dotimes (i m NIL) .*** Imprimir resultados (format t "~%Matriz original.*** Pedir datos del arreglo (dotimes (j n NIL) (format t "Elemento [~D.

Lista del tipo (nombreComponente valor-default nombre-opción1 valor-opción1 nombre-opciónk valor-opciónk)  defstruct define también las siguientes funciones: Un constructor make-nombreEstructura  Una función de acceso por cada componente de la estructura nombreEstructura-nombreComponente  Una función de copia de estructuras copy-nombreEstructura  Una función predicado para instancias de la estructura (typep variableTipoEstructura nombreEstructura) evalúa a T   Las funciones de acceso permiten modificar los valores de los componentes de la estructura. . (defstruct nombreEstructura elem1 elem2 elemk) elemi (descripción de los elementos de la estructura):    Símbolo.Estructuras Complejas Estructuras Objetos de datos conformados por elementos con nombre. en conjunción con SETF.

*** Segundo registro del directorio (make-contacto :nombre 'Ecsar :tel '3-11-11-11 :direccion '(Calle Ecsar No.*** Primer registro del directorio (make-contacto :nombre 'Bere :tel '3-00-00-00 :direccion '(Calle Bere No.*** Agenda telefónica (defstruct contacto .*** Define la estructura contacto con 3 componentes nombre tel direccion) (setf (aref *dir* 0) .*** Modificar tercer registro (setf (contacto-nombre (aref *dir* 2) ) '(Ecsar Modificado) ) (setf (contacto-tel (aref *dir* 2) ) '1-33-33-33 ) (setf (contacto-direccion (aref *dir* 2) ) '(Calle Ecsar Modificada No.Estructuras Complejas (defconstant *MAXDIR* 5 "Número máximo de entradas en directorio") (setf *dir* (make-array (list *MAXDIR*))) . 1) ) ) (setf (aref *dir* 2) . 0) ) ) (setf (aref *dir* 1) . 3) ) (dotimes (i 3 NIL) .*** Imprimir resultados (format t "~%Contacto[~D]:" i) (format t "~%Nombre: ~A" (contacto-nombre (aref *dir* i) )) (format t "~%Teléfono: ~A" (contacto-tel (aref *dir* i) )) (format t "~%Dirección: ~A" (contacto-direccion (aref *dir* i) )) (terpri) ) .*** Copiar tercer registro del directorio (copy-contacto (aref *dir* 1) ) ) .

6)) (Ramiro 7-77-77-77 (Calle Ramiro No. 5)) (Mar 6-66-66-66 (Calle Mar No. (assoc llave lista :TEST función-comparación) Busca en la lista de asociación lista y devuelve el primer par cuyo CAR iguale llave. 3)) (Écsar 4-44-44-44 (Calle Écsar No. (setf x (assoc 'José '( (Bere 3-33-33-33 (Calle Bere No.Estructuras Complejas  Listas de Asociación Lista L en la cual i  L. li es una lista y (car li) sirve como llave de búsqueda de la asociación. Si no hay coincidencia se devuelve NIL. El argumento opcional :TEST es la función particular utilizada para realizar la comparación. 4)) (José 5-55-55-55 (Calle Pepe No. 7)) :test #'EQUAL) ) ) .

Si no existe asociación. (gethash valor nombre-tabla) Recupera el elemento asociado en la tabla nombre-tabla con la llave valor. Especificada en la forma # EQUAL. (make-hash-table opciones) opciones:     :SIZE Poporciona una idea al systema Lisp del tamaño inicial de la tabla. que sirve para la búsqueda (asociativa) optimizada. :REHASH-SIZE Indica el tamaño de redimensionamiento de la tabla. Siempre se devuelve un segundo valor: T si se encontró una asociación y NIL si no. una vez que se alcanza el umbral indicado por la opción siguiente. la función por defecto es # EQL. a menos que se especifique otro como tercer argumento). :TEST Función de comparación para la búsqueda. se devuelve un valor por defecto (NIL. no es importante que sea totalmente correcto (entero). (describe nombre-tabla) Describe la información básica de la tabla (inspect nombre-tabla) Describe todas las características de la tabla hash y entra a un intérprete de línea de órdenes que permite ver interactivamente los datos que se han introducido hasta el momento (en la tabla). Crea y devuelve una tabla hash. .Estructuras Complejas  Tablas Hash Colección de datos identificados por medio de una llave (cada elemento en la tabla). :REHASH-THRESHOLD Umbral de disparo del redimensionamiento de la tabla hash.

Estructuras Complejas (defvar *dir* NIL "Agenda telefónica") (setf *dir* (make-hash-table :test #'equal :size 100) ) .*** Ver tabla con PRINT/PRINTC/PRIN1 . 7))) (princ "Búsquedas: ") .*** Crear agenda telefónica (princ "Inicializaciones: ") . 4 ))) (setf (gethash 'José *dir*) '(5-55-55-55 (Calle Pepe No.*** Introducir datos de los "contactos" (setf (gethash 'Bere *dir*) '(3-33-33-33 (Calle Bere No. 5 ))) (setf (gethash 'Mar *dir*) '(6-66-66-66 (Calle Mar No. 6 ))) (setf (gethash 'Ramiro *dir*) '(7-77-77-77 (Calle Ramiro No.*** Búsquedas de ejemplo (princ "Mar: ") (princ (gethash 'Mar *dir*)) (princ "Sergio: ") (princ (gethash 'Sergio *dir*)) (princ "Bere: ") (princ (gethash 'Bere *dir*)) (princ "Descripción: ") (describe *dir*) (princ "Ver tabla con PRINC:") (princ *dir*) . 3 ))) (setf (gethash 'Écsar *dir*) '(4-44-44-44 (Calle Écsar No.*** Obtener la descripción de la tabla hash .

Áreas de Aplicación  Inteligencia Artificial  Producciones y Empatamiento ( Productions and Matching ) Representación de Conocimiento ( Knowledge Representation ) Aprendizaje de la computadora ( Machine Learning )  Razonamiento Lógico y Probabilístico  Razonamiento por Sentido Común  Planeación Procesamiento de Lenguaje Natural ( Natural Language Processing )  Redes Neuronales  Algoritmos Genéticos Modelado de Visión y Voz ( Modeling of Vision and Speech )  Redes Neuronales  Algoritmos Genéticos Sistemas Expertos      .

Comparación con Otros Lenguajes Funcionales Característica Separador de Listas Notación ¿ Fuertemente Tipado ? Ámbito de Variables ¿ Lenguaje Puro ? Tamaño del Lenguaje Orientación a Objetos Tipo de Recursión Tipo de Evaluación ¿ Comprensión de Listas / Listas Infinitas ? Lisp Paréntesis Prefija Sí Léxico / Estático No Grande/complejo CLOS General Estricta No Scheme Paréntesis Prefija No Dinámico No Sencillo No De Cola Estricta No No Haskell Brackets Infija Sí Léxico / Estático Sí Grande Librerías General Postergada ( lazy ) Sí Sí Series Aritméticas en Listas No .

6. ]  cuadrados = [ n * n | n  [ 0 ..Comparación con Otros Lenguajes Funcionales  CLOS   Common Lisp Object System. 4. Listas Infinitas:  positivos = [ 0 . 4 . utilizados en una expresión.. 8. 10 ] . ] ]  Series Aritméticas:  [ 2. 10 ] se expande a [ 2.. hasta el momento real en que se ocupe.  Lazy Evaluation Postergar la evaluación de un parámetro o variable.

Touretzky. IV. Allen y Noonan. D. New York. 185-195. 2nd. Recursive functions of symbolic expressions and their computation by machine. 2003. II. 4. Recursos en Internet: I. S. NY: Computer Science Press.cons. A. 1995. III. Tucker. pp. No. McGraw Hill / Interamericana de España. 1990.org http://www. Lenguajes de Programación: Principios y Paradigmas. Vol. 1941.schemers. 2. McCarthy. J. The Calculi of Lambda Conversion. Steven. 4. CA: Benjamin / Cummings.org http://www. A.haskell. NJ: Princeton University Press. ed.Referencias 1. 5.wikipedia. Princeton. U. 3. Redwood City. Part. Tanimoto. http://clisp.org . 3. Church. Robert. The Elements of Artificial Intelligence Using Common LISP. Communications of the ACM. I.. 1960.org http://www. S. Common LISP: A Gentle Introduction to Symbolic Computation.

Gracias Por Su Atención .