Beruflich Dokumente
Kultur Dokumente
Leccines
Segn el mtodo de evaluacin Evaluacin estricta (eaguer) Evaluacin diferida (lazy, perezosa) Segn la asignacin Lenguajes funcionales puros o sin asignacin Lenguajes funcionales con asignacin Mquina abstracta para un lenguaje con evaluacin eager (directa) FAM mquina basada en mbitos Mquina abstracta para un lenguaje con evaluacin lazy (diferida) G-Machine mquina basada en grafos y combinadores.
Problema de los lenguajes funcionales puros Un lenguaje funcional puro no tiene asignacin. Por lo tanto, los cambios de estado solo se pueden realizar creando nuevas variables, o sea, realizando llamadas a funciones. Un programa que interaccione con el mundo real ha de cambiar su estado para representar el nuevo estado del mundo. Si para cada llamada a funcin se utiliza espacio de pila, el resultado es que el programa llenar la pila. Solucin: Optimizacin de la recursividad en cola La interaccin se implementa en un lenguaje imperativo con un bucle que procesa los eventos que vienen del mundo. En un lenguaje funcional se implementa con una funcin que procesa un evento y que al final se llama recursivamente para procesar en siguiente evento (recursividad en cola). Objetivo: Conseguir que la ltima llamada que realiza una funcin no consuma pila.
Pila anterior b a PC f ED c d e d c
Bloque de activacin de f
Parmetros de g
Contenido de la pila que necesita la llamada a g. El bloque de activacin de f se puede eliminar ya que lo ltimo que se hace es llamar a g. Problema: despus del bloque de activacin de f se encuentran los parmetros de g
Pila anterior d c PC f
Recursividad en Cola: Pila de contexto con los bloques de activacin un pila de Solucin parmetros.
De esta forma se evita que los parmetros impidan la eliminacin del bloque de activacin antes de la ltima llamada Los parmetros se han de copiar de la pila de argumentos al bloque de activacin o mbito de la funcin
Pila de Contexto
EP
CSP
AP Pila de Argumentos
Cdigo Llamada
Calcular los argumentos y ponerlos en la pila de argumentos Llamar a la funcin
Cdigo Funcin
Guardar EP en la pila Copiar argumentos de la pila de argumentos a la pila de contexto Inicializar espacio de variables Cuerpo de la funcin Poner el valor de retorno en un registro
Cdigo funcin
PushCon EP EP=SP PopArg VR PushCon VR PopArg VR
PushCon VR
PushCon NIL Cuerpo funcin SP=EP PopCon EP Ret
SP=EP
PopCon EP Ret
Eliminar bloque de activacin de f antes de llamar
Ret
Cdigo optimizado
10
Una clausura es
11
Fun f(x)={
Implementacin de Clausuras
Bloque de activacin de g PC EP EP f a b z
EP
Display
Ambitos en el Heap
se puede acceder a las variables de f. Por lo tanto, no se puede eliminar el mbito de f al finalizar su ejecucin
Guardar el mbito de f en el heap para que no se elimine al salir de f Los mbitos en el heap existirn hasta que no se pueda acceder a ellos
Pila anterior PC EP SP
nulo x y Env
EP
13
Cdigo Llamada
Calcular los argumentos y ponerlos en la pila de argumentos Llamar a la funcin
Cdigo Funcin
Guardar EP en la pila Crear nodo de mbito en el heap e inicializarlo EP apunta al nodo de mbito Copiar argumentos de la pila de argumentos al mbito Cuerpo de la funcin Poner el valor de retorno en un registro Recuperar EP de la pila de contexto retornar
14
EP
Ambito en el Heap
Heap nulo EP
Pila de contexto PC EP
15
Cdigo Llamada
Calcular los argumentos y ponerlos en la pila de argumentos Clo=Clausura Llamar a la funcin
Cdigo Funcin
Guardar EP en la pila de contexto Crear el Display a partir del EP de Clo Copiar argumentos de la pila de argumentos a la pila de contexto Inicializar espacio de variables en la pila de contexto Cuerpo de la funcin
16
Pila de Contexto
EP CSP
AP
Pila de Argumentos Heap PC
17
En el Heap se guarda
Nodos de listas, smbolos, paquetes, etc. Cdigo de las funciones (puede estar en un segmento de memoria aparte si no puede variar) Clausuras Bloques de mbito accesibles desde fuera de la funcin que los ha creado
18
Cdigo de llamada
Poner los argumentos en la pila de argumentos Nargs=Nmero de argumentos Call funcion
Cdigo de la funcin
Verificar del nmero de argumentos (NArgs) Guardar EP en la pila de contexto Crear el mbito (EP apunta hacia el)
Copiar el Display de la clausura de la funcin
Leer los argumentos y ponerlos en el mbito Ejecutar el cuerpo de la funcin (deja el valor de retorno en la pila de argumentos Eliminar el mbito Recuperar EP de la pila de contexto retornar
19
Poner Arg.
Crear mbito
Sacar Arg
Ejecutar cuerpo
Salir
(10 20)
(10 20)
20
Funcin:
Poner Arg.
Crear (labels ((gSacara x))) Ejecutar (a) (+ Arg mbito(list x (g y)))) cuerpo
Llamada: (f 10 20)
(defun f (x y)
Salir
PC de ret PC de ret EP EP X=10 X=10 Y=20 Y=20 PC de ret PC de ret EP(ED) Disp:EP f a
PC de ret PC de ret EP EP X=10 X=10 Y=20 Y=20 PC de ret EP(ED) Disp:EP f a=20
20 10
20 10
10
30 10
30 10
21
Clausuras
Una clausura un cdigo de una funcin junto clausura de g es mbito en quede F de ejecutarcon mbito se ha el apuntador al la funcin. X=10 Ejemplo: clausura de g: Y=20
Cdigo de G
22
Funcin que retorna dos funciones ligadas por una variable local
(defun varEscondida (n) (list (lambda (x) (+ x n)) (lambda (x) (setq n x))
)
) (setq a (varEscondida 10)) (#<Closure: #ffd8b044> #<Closure: #ffd8b020>) (funcall (first a) 5) 15 (funcall (second a) 30) 30 (funcall (first a) 5) 35
23
{x 2 | x [1..100 ], x mod 5 0}
Por ejemplo
Expresa el conjunto de los cuadrados de los nmeros pertenecientes al intervalo [1,100] divisibles por 5.
Por lo anterior se ha implementado en los lenguajes de programacin funcionales Hope, Miranda, Haskell, etc., pero se cambia el conjunto por lista. Notacin: [expresin | generadores y guardas]
Generador: variable <- lista o intervalo
Guarda: condicin
Ejemplo: [x**2
| x<-1..100,
x%5==0]
24
Generadores y Guardas
Guardas condicin
Si la condicin se cumple se evaluar la expresin y se guardar en la lista resultante
Ejemplos
Resultado:
[(3,2),(9,6),(9,4),(9,2)]
25
Fun Sort(l:List)=> { if (l==[]) [] else { Var menores=[]; for (e<-l.Tail) if (e<l.Head) menores=e::menores; Var mayores=[]; for (e<-l.Tail) if (e>=l.Head) mayores=e::mayores; Sort(menores)++[l.head]++Sort(mayores) } }
26
Quicksort in Haskell
qsort []
= []
where
elts_lt_x
Quicksort in C
int h, l, p, t;
l = lo;
h = hi;
p = a[hi];
do {
l = l+1;
h = h-1;
if (l < h) {
t = a[l];
a[l] = a[h];
a[h] = t;
t = a[l];
a[l] = a[hi];
a[hi] = t;
qsort( a, l+1, hi );
27
(defmacro listcomp (Exp &rest Conds) (let ((SymList (gensym "LIST")) (SymP (gensym "P"))) `(let* ((,SymLIST (cons nil nil)) (,SymP ,SymLIST)) ,(ListComp2 Exp Conds SymP) (cdr ,SymLIST) )
)
) (defun ListComp2 (E Q L) (cond ((null Q) `(progn (setf (cdr ,L) (cons ,E nil)) (setq ,L (cdr ,L))) ) ((and (consp (car Q)) (eq (caar Q) 'in)) `(dolist (,(cadar Q) ,(caddar Q)) ,(ListComp2 E (cdr Q) L) ) ) (T `(when ,(car Q) ,(ListComp2 E (cdr Q) L))) ) )
28
Ejemplo
(setq l (1 10 5 2 9)) (ListComp (* x x) (in x l) (> x 3)) Resultado: (100 25 81) Cdigo generado:
(LET* ((LIST5 (CONS NIL NIL)) (P6 LIST5)) (DOLIST (X L) (WHEN (> X 3) (PROGN (SETF (CDR P6) (CONS (* X X) NIL)) (SETQ P6 (CDR P6))))) (CDR LIST5))
Cdigo optimizado:
(LET* ((LIST5 (CONS NIL NIL)) (P6 LIST5)) (DOLIST (X L) (WHEN (> X 3) (SETF (CDR P6) (CONS (* X X) NIL)) (SETQ P6 (CDR P6)))) (CDR LIST5))
29
Fun ListComp(Exp,Conds)=> { Var SList=symbol("Lista"), SP=symbol("Posicion"); Fun ListComp2(Conds)=> { if (Conds==[]) << { *<SymP> = [<Exp>]; <SP> = &<SP>->Tail; } >> else if (ApplyFunP(Conds.Head,`\<-,2)) { // Generador Var sl=symbol("ListaGenerador"), sv=Conds.Head.Arg(0); Var srepetir=symbol("Repetir"); << { Var <sl> = <Conds.Head.Arg(1)>; Label <sRepetir>; if (<sl> != []) { Var <sv> = <sl>.Head; <ListComp2(Conds.Tail)>; <sl> = <sl>.Tail; goto <sRepetir>; } } >> } else { // Condicin << if (<Conds.Head>) <ListComp2(Conds.Tail)> >> } } << { Var <SList> = [], <SP> = &<SList>; <ListComp2(Conds)>; <SList> } >> }
30
Ejemplo
Var ListaGenerador=li;
Label Repetir; if (ListaGenerador!=[]) { Var x=ListaGenerador.Head; if (x>10) { &Posicion=[x]; Posicion=&Posicion->Tail; } ListaGenerador=ListaGenerador.Tail; GoTo Repetir } } Lista }
31
Pattern Maching