Programacin funcional:

El lenguaje LSP
Universidad de Costa Rica
Escuela de Ciencias de la Computacin e nformtica
C-1441 Paradigmas Computacionales
Prof. Dr. A. de la Ossa O.
Mayo del 2013
Contenido
!
ntroduccin rpida a la programacin funcional
!
Origen de la programacin funcional
!
El lenguaje LSP
"
Operadores primitivos
"
Notacin funcional
ntroduccin rpida a la
programacin funcional
!
Sintaxis de la definicin de una funcin LSP:
(defun nombre-de-funcin(lista-de-argumentos)
cuerpo-de-la-funcin)
!
Ejemplo: el valor absoluto de un nmero
(defun absoluto(x)
(cond ((< x 0)(- x))
(t x)))
ntroduccin rpida a la
programacin funcional
!
El intrprete LSP: mquina iterativa, cada ciclo es...
Lectura (read)
Evaluacin (eval)
Salida (print)
!
Expresiones: listas de la forma
(funcin arg
1
arg
2
. arg
N
)
Sintaxis de una definicin funcional
(defun absoluto(x)
(cond ((< x 0)(- x))
(t x) ))
Nombre de la funcin Parmetro
Condicional
Si x es menor a 0
entonces devuelva -x
en otro caso, devuelva x
(ojo: notacin prefija)
Ejemplos
!
Tamao de una lista
(defun tamao (l)
(cond ((null l) nil)
(t (+ 1 (tamao (cdr l))))))
!
Factorial de un nmero
(defun fact (n)
(cond ((eq n 0) 1)
(t (* n (fact (- n 1))))))
En qu se parecen estas definiciones?
es vaca?
devuelva la lista vaca
en otro caso, devuelva el
tamao de la cola ms 1
es 0 o lleg a 0?
devuelva 1
en otro caso, devuelva el
factorial de n-1 por n
Ms ejemplos
!
Miembro de una lista
(defun miembro (x l)
(cond ((null l) nil)
((eq x (car l)) l)
(t (miembro x (cdr l)))))
!
N-simo elemento de una lista
(defun nesimo (n l)
(cond ((eq n 0) nil)
((eq n 1) (car l))
(t (nesimo (- n 1) (cdr l)))))
En qu se parecen estas definiciones?
llegamos al final de la lista?
llegamos al final de la lista?
devuelva la lista vaca
devuelva la lista vaca
en otro caso, determine
si est en la cola
en otro caso, determine
si est en la cola
Las funciones car y cdr ("cudru)
!
La cabeza de una lista: (car '(a b)) a
!
La cola de una lista: (cdr '(a b)) (b)
!
Y podemos definir
(defun primero (l) (car l))
(defun segundo (l) (car (cdr l)))
(defun segundo2 (l) (cadr l))
(defun tercero (l) (car (cdr (cdr l))))
(defun tercero2 (l) (caddr l))
Ms ejemplos
!
Concatenacin de dos listas
(defun concatena (x y)
(cond ((null x) y)
(t (cons (car x)
(concatena (cdr x)
y)))))
!
Comprese con la definicin en Prolog
concatena([],_,[]).
concatena([X|Xr],Y,[X|Zr]) :-
concatena(Xr,Y,Zr).
Ms ejemplos
!
Reemplazo de elementos de una lista
(defun reemplaza (x l y)
(cond ((null l) nil)
((eq x (car l))
(cons y
(reemplaza x (cdr l) y)))
(t (cons (car l)
(reemplaza x (cdr l) y)))))
Origen de la programacin funcional
!
Creado por John McCarthy en 1956, en Dartmouth
College (Hanover, New Hampshire, EE.UU.).
Publicado en 1960
!
Sus estrategias fundamentales son la composicin
funcional y la recursin
!
LSP = LSt Processing
Origen de la programacin funcional
!
McCarthy muestra en su artculo de 1960 cmo se
puede construir un lenguaje de programacin a partir
de un conjunto de operadores simples y una notacin
para funciones.
!
LSP representa un hito en la historia de la
computacin: es un modelo de computacin hacia el
que se han movido otros lenguajes
Caractersticas
!
Caractersticas propias de LSP (e incorporadas en
un lenguaje de programacin por primera vez):
1. Condicionales previamente solo exista el "go to condicional
2. El tipo "funcin las funciones son los objetos fundamentales del
lenguaje, son un tipo de dato tal como enteros, hileras, etc. y
pueden ser almacenados en variables o pasados como
argumentos
3. Recursin primer lenguaje en utilizar este paradigma
4. Concepto propio de variable las variables de un programa LSP
son punteros por lo que cambiar el valor de una variable consiste
en redirigir el puntero a otra expresin
Caractersticas
!
Caractersticas propias de LSP (cont...):
1. Recoleccin de basura
2. Programas = rboles de expresiones evaluables (funciones, que en
algunas implementaciones pueden devolver valores mltiples)
NO hay distincin entre cdigo y datos en un programa
Ejemplo: (if foo (= x 1) (= x 2)) equivalente a (= x (if foo 1 2))
3. El tipo "smbolo Los smbolos son diferentes de las hileras; la
comparacin de igualdad de dos smbolos consiste en comparar
los objetos a los que apuntan sus punteros
Caractersticas
!
Caractersticas propias de LSP (cont...):
1. Notacin simple El cdigo de un programa consiste en un rbol
de smbolos
2. Disponibilidad completa independientemente de las acciones
" Resumen:
! 1, 2, 3, 4, 5 de uso comn en los lenguajes modernos
! 6 pocos lenguajes lo utilizan
! 7 Python lo hace en forma similar
! 8 y 9 hacen posible la programacin de "funciones macro
Expresiones
!
Una expresin LSP puede ser ya sea...
"
un tomo (secuencias de caracteres, iniciando con letra), o
"
una lista de cero o ms expresiones separadas por espacios
y encerradas entre parntesis
"
Ejemplos:
!
x el smbolo "x
!
() la lista vaca
!
(f x) la lista con los smbolos f y x
!
(a b (c d) e) una lista anidada o rbol de
expresiones
Operadores primitivos
!
El operador quote: devuelve su argumento
(quote 'a) devuelve a
(quote '()) devuelve nil o ()
(quote '(a b c)) devuelve (a b c)
Operadores primitivos
!
El operador atom: es un predicado sobre la
propiedad de ser tomo
(atom 'a) devuelve t (verdadero)
(atom '(a b c)) devuelve nil o () (falso)
(atom '()) devuelve t (verdadero)
(atom (atom 'a)) devuelve t (verdadero)
(atom '(atom 'a=) devuelve nil o () (falso)
Operadores primitivos
!
El operador eq: devuelve t si sus dos argumentos
son el mismo tomo o ambos la lista vaca; nil o ()
en otro caso
(eq 'a 'a) devuelve t
(eq 'a 'b) devuelve nil o ()
(eq '() '()) devuelve t
Operadores primitivos
!
El operador car: espera que su argumento sea una
lista y devuelve su primer elemento o cabeza
(car '(a b c)) devuelve a
(car 'a) devuelve un mensaje de error
(car '()) devuelve ()
Operadores primitivos
!
El operador cdr: espera que su argumento sea una
lista y devuelve la lista sin su primer elemento (es
decir, el resto o cola); se pronuncia "cudru
(cdr '(a b c)) devuelve (b c)
(cdr 'a) devuelve un mensaje de error
(cdr '()) devuelve ()
Operadores primitivos
!
El operador cons: espera dos argumentos, el
segundo debe ser una lista, y devuelve una lista que
contiene al primero en la cabeza y al segundo en la
cola
(cons 'a '(b c)) devuelve (a b c)
(cdr 'a (cons 'b (cons 'c '())))
devuelve (a b c)
(car (cons 'a '(b c)))
devuelve a
(cdr (cons 'a '(b c)))
devuelve (b c)
Operadores primitivos
!
El operador cond: espera n argumentos, cada uno
de ellos una lista con dos elementos: una condicin y
una accin; se evalan las condiciones en orden
hasta que cualquier de ellas devuelve t; en ese caso
se devuelve el valor de la accin asociada
(cond ((eq 'a 'b) 'primero)
((atom 'a) 'segundo)
(t 'ninguno))
devuelve segundo
Notacin funcional
!
Una funcin es expresada como
((lambda (p1 ... pn) e) a1 ... an)
donde:
"
Los pi son tomos llamados parmetros
"
El trmino e es una expresin
"
Toda la expresin es una llamada de funcin
"
Los ai son expresiones llamadas argumentos
Notacin funcional
!
Una llamada de funcin
((lambda (p1 ... pn) e) a1 ... an)
es evaluada como sigue:
"
Se evalan una a una las expresiones ai
"
Se evala e; en el transcurso de esa evaluacin cada pi es
asociado con su correspondiente ai
Notacin funcional
!
Ejemplos de llamadas de funcin
((lambda (x) (cons x '(b))) 'a)
devuelve (a b)
((lambda (x y) (cons x (cdr y))) 'z '(a b c))
devuelve (z b c)
Notacin funcional
!
Si una expresin (lista) tiene como primer elemento
un tomo f que no es un operador primitivo
(f a1 ... an)
y f apunta a una funcin
(lambda (p1 ... pn) e)
entonces se devuelve el valor de
((lambda (p1 ... pn) e) a1 ... an)
Notacin funcional
!
Es decir, que los parmetros pueden usarse como
operadores en expresiones o como argumentos:
((lambda (f) (f '(b c)))
'(lambda (x) (cons 'a x)))
devuelve (a b c)
Notacin funcional
!
Notacin alterna que permite que una funcin se
refiera a s misma (base para la definicin de
funciones recursivas):
(label f (lambda (p1 ... pn) e))
denota una funcin que se comporta como lo especifica la
expresin lambda, con la propiedad adicional de que una
ocurrencia de f dentro de e devolver la expresin label, como
si f fuese un parmetro de la funcin.
Ejemplo
!
Se desea definir una funcin (subst x y z) que
devuelve una lista como z pero con cada instancia
del tomo y (en cualquier nivel de anidamiento)
reemplazada por la expresin x.
> (subst 'm 'b '(a b (a b c) d))
devuelve (a m (a m c) d)
Ejemplo
! (label subst
(lambda (x y z)
(cond ((atom z)
(cond ((eq z y) x)
('t z)))
('t (cons (subst x y (car z))
(subst z y (cdr z)))))))
! Si abreviamos (label f (lambda (p1 ... pn) e)) como
(defun f (p1 ... pn) e), entonces la definicin es:
(defun subst (x y z)
(cond ((atom z)
(cond ((eq z y) x)
('t z)))
('t (cons (subst x y (car z))
(subst z y (cdr z)))))))
Referencia: Primitivas en la
versin original de McCarthy
!
(defun null. (x)
(eq x '()))
! (defun and. (x y)
(cond (x (cond (y 't) ('t '())))
! (defun not. (x)
(cond (x '()) ('t t)))
!
(defun append. (x y)
(cond ((null. x) y)
('t (cons (car x)(append. (cdr x) y)))))
Referencia: Primitivas en laversin
original de McCarthy
!
(defun pair. (x y)
(cond ((and. (null. x) (null. y)) '())
((and. (not. (atom x)) (not. (atom y)))
(cons (list (car x) (car y))
(pair. (cdr x) (cdr y))))))
> (pair. '(x y z) '(a b c)) -> ((x a) (y b) (z c))
! (defun assoc. (x y)
(cond ((eq (caar y) x) (cadar y))
('t (assoc. (cdr y)))))
> (assoc. 'x '((x a) (y b))) -> a
Ejercicio: Factorial pseudoiterativo
(defun factpi (n)
(factpseudo 1 1 n))
(defun factpseudo (prod cont max)
(cond ((> cont max) prod)
(t (factpseudo (* cont prod)
(+ cont 1)
max))))
Ejercicio: Factorial pseudoiterativo
factpseudo tambin puede escribirse as:
(defun factpseudo (prod cont max)
(if (> cont max)
prod
(factpseudo (* cont prod) (+ cont 1) max)))
Ejercicio: Primeros n primos
Objetivo: determinar si un nmero n (positivo) es primo
(defun es_primo (n)
(cond ((<= n 0) nil)
(t (es_primo_aux n (- n 1)))))
(defun es_primo_aux (n m)
(cond ((<= m 1) t)
((zerop (rem n m)) nil)
(t (es_primo_aux n (- m 1)))))
Ejercicio: Primeros n primos
Objetivo: construir una lista con los n primeros primos
entre 0 y z
(defun n_primos (n z) (n_primos_aux n 0 z))
(defun n_primos_aux (n cont fin)
(cond ((zerop n) nil)
((eq cont fin) nil)
((es_primo cont)
(cons cont (n_primos_aux (- n 1)
(+ cont 1)
fin)))
(t (n_primos_aux n (+ cont 1) fin))))
Ejercicio: Primeras n potencias de x
Objetivo: construir una lista con las n primeras
potencias de x
(defun serie_pot (x n)
(serie_pot_aux x n 1))
(defun serie_pot_aux (x n y)
(cond ((zerop n) nil)
(t (cons (* x y)
(serie_pot_aux x
(- n 1)
(* x y))))))