Programación funcional

Transcripción

1 Programación funcional Inferencia de tipos manual para programas Haskell J. Sánchez Hernández Enero de 2007 El sistema de tipos de Haskell Es una variante del propuesto R. Milner en 1978 (con antecedentes en J.R. Hindley, 1969). admite polimorfismo paramétrico toda expresión tiene un tipo principal, o bien no es tipable hay un algoritmo de inferencia para deducir el tipo principal de cualquier expresión (o decidir que está al tipada).

2 Tipo de una expresion Se siguen los siguientes pasos: 1 Decorar de la forma id :: <tipo> cada identificador id (de variable o de función) y cada resultado de una aplicación (bien sea de función o de constructora) con una instancia fresca de su tipo si se conoce o con una variable fresca a en caso contrario, teniendo en cuenta que: las apariciones de una variable en la misma expresión han de estar decoradas con el mismo tipo (puesto que deben tener el mismo tipo) cada aparición de una función con tipo conocido ha de tener una instancia fresca de su tipo (polimórfico). las tuplas (e 1,..., e n ) pueden decorarse directamente con (a 1,..., a n ) 2 Generar las ecuaciones según la siguiente regla: e 0 :: t 0 e 1 :: t 1... e n :: t n (e 0 e 1... e n ) :: t t 0 = t 1... t n t Tipo para una regla de función 3 Resolver las ecuaciones generadas mediante un algoritmo de unificación, teniendo en cuenta que: las tuplas y listas (y cualquier otra constructora) se descomponen de manera ordinaria. Por ejemplo la ecuación (t 1, t 2 ) = (t 1, t 2 ) se descompone en las dos ecuaciones t 1 = t 1, t 2 = t 2 y [t 1] = [t 2 ] se descompone en t 1 = t 2. el constructor de tipo se comporta como una constructora mas, i.e., una ecuación de la forma t 1 t 2 = t 1 t 2 se descompone en dos ecuaciones t 1 = t 1, t 2 = t 2 Si el algoritmo tiene éxito proporciona el tipo principal para la expresión (y cada una de sus subexpresiones). Si falla, la expresión está mal tipada. Nota: recordemos que la aplicación asocia por la izquierda y el operador por la derecha.

3 Algoritmo de unificación de Martelli-Montanari Aplicar alguna de las siguientes reglas mientras sea posible: 1. S {X = X } S 2. S {f (t 1,..., t n )=f (s 1,..., s n )} S {t 1 =s 1,..., t n =s n } 3. S {f (t 1,..., t n ) = g(s 1,..., s m )} FALLO, si f g (ó n m) 4. S {X = t} S[X /t] {X = t}, si X var(t), X var(s), X t 5. S {X = t} FALLO, si X var(t) 6. S {t = X } S {X = t}, si t V Este algoritmo proporciona u.m.g. s idempotentes Ejemplo Supongamos la expresión: True == (False (not False)) Sabemos que: (==) :: a a Bool y que not :: Bool Bool, ( ) :: Bool Bool Bool. Para facilitar las cosas ponemos la expresión en forma prefija Decoramos: (==) True (( ) False (not False)) ((==) :: a a Bool True :: Bool (( ) :: Bool Bool Bool False :: Bool (not :: Bool Bool False :: Bool) :: b ) :: c ) :: d

4 Ecuaciones: Bool Bool = Bool b Bool Bool Bool = Bool b c a a Bool = Bool c d Resolvemos: a = Bool, b = Bool, c = Bool, d = Bool Otro ejemplo: map (+1) [2] Para facilitar las cosas utilizamos notación prefija en todos los operadores y la lista [2] la escribimos de la forma (:) 2 [], sabiendo que: (:) :: a [a] [a] Inferencia de tipos para reglas de función f p }{{} cabeza = e }{{} cuerpo Se decora la cabeza y el cuerpo, y se plantean las ecuaciones del mismo modo, pero con una ecuación adicional entre el tipo de la cabeza y el del cuerpo. Si hay guardas también se decoran y se plantean las ecuaciones oportunas. Ejemplo: cua x = x x (suponiendo ( ) :: Int Int Int) Decoramos: (cua::a x::b)::c = ((*)::Int Int Int x::b x::b)::d Ecuaciones: {a = b c, Int Int Int = b b d, c = d} Resolvemos: b = Int, c = Int, d = Int, a = Int Int (luego cua :: Int Int)

5 Tipo para funciones Se decora cada una de las reglas de función, anotando el mismo tipo en todas las reglas para todas las apariciones de la función que se está definiendo. Si el algoritmo de unificación tiene éxito el tipo obtenido para la función es el tipo más general. Si no tiene éxito, la función está mal tipada. Si la función tiene tipo declarado se comprueba que dicho tipo sea una instancia del tipo inferido, i.e., que el tipo inferido es más general que el declarado. Si es así, se anota el tipo declarado para la función, en otro caso, error. Tipo para lambda-expresiones λx e se decoran x, e y la propia lambda expresión del modo habitual, (λx :: a e decorada :: b) :: c se plantean las ecuaciones resultantes de e decorada y una ecuación adicional c = a b se resuelve del modo ordinario Las λ-expresiones con más de un argumento se reducen al caso de un argumento. Por ejemplo: λx y e) se decora como (λx :: a 1 (λy :: a 2 e decorada :: a 3 ) :: a 4 ) :: a 5 y se añaden las ecuaciones adicionales: a 4 = a 2 a 3, a 5 = a 1 a 4

6 Tipo para expresiones con let let in e <defs. locales>... Las definiciones locales: se decoran del modo habitual, se plantean las ecuaciones y se resuelven. Para la expresión externa: Se decora e utilizando los tipos inferidos en el paso anterior: el tipo de las variables globales queda congelado (no se toman instancias frescas) para el resto de variables/funciones se toman instancias frescas Se plantean y resuelven las ecuaciones del modo habitual. Ejemplo Sea h x y = (x, y) con el tipo ya inferido h :: a b (a, b) y f x = let g y = h x y in (x, g 3, g x, g True) Decoramos la definición local: (g :: a 1 y :: a 2 ) :: a 3 = (h :: a 4 a 5 (a 4, a 5 ) x :: a 6 y :: a 2 ) :: a 7 Ecuaciones: a 1 = a 2 a 3, a 4 a 5 (a 4, a 5 ) = a 6 a 2 a 7, a 3 = a 7 Resolvemos: a 1 = a 2 (a 4, a 2 ), a 3 = (a 4, a 2 ), a 6 = a 4, a 5 a 2, a 7 = (a 4, a 2 ) Lo que nos interesa: g :: a 2 (a 4, a 2 ) y x :: a 4, con a 4 congelada g :: a 2 (a 4, a 2 ) x :: a 4

7 Ahora procedemos con la expresión externa: Cada aparición de g utiliza una instancia fresca del tipo inferido x :: a 4 es variable global (externa) a 4 Decorando: queda congelado (f :: c 0 x :: a 4 ) :: c 1 = ( x :: a 4, (g :: b 1 (a 4, b 1) 3 :: Int) :: a 8, (g :: b 3 (a 4, b 3) x :: a 4 ) :: a 9, (g :: b 5 (a 4, b 5) True :: Bool) :: a 10 ) :: (c 2, c 3, c 4, c 5 ) Resolviendo tenemos f :: a 4 (a 4, (a 4, Int), (a 4, a 4 ), (a 4, Bool)) Ejercicio: f x = let g y = h x y in (fst (g 3) + fst (g x), g True) Tipo para programas En general, si una función f utiliza otra g en su definición el tipo de g deberá inferirse antes que el tipo de f.... pero puede haber funciones mútuamente recursivas, cuyo tipo ha de inferirse simultáneamente. Esto hace que el algoritmo sea algo más sofisticado de lo que cabría esperar: Construir el grafo de dependencias funcionales: los nodos son los nombre de función; si f utiliza g en su definición habrá un arco de f a g. Determinar las componentes fuertemente conexas del grafo (que corresponden a definiciones mutuamente recursivas). Calcular la ordenación topológica de dichas componentes. Los tipos se inferiran en dicho orden.

8 Ejemplo even 0 = True even n = odd (n-1) odd 0 = False odd n = even (n-1) Recursión mutua! Los tipos se infieren a la vez: se decoran todas las reglas y se plantean las ecuaciones correspondientes. Inferencia de tipos con sistema de clases El algoritmo es esencialmente el mismo, pero se anotan las cualificaciones/restricciones de tipo al decorar las expresiones se propagan al resolver las ecuaciones. Además cuando una misma variable está afectada por dos restricciones de clase se conserva la más restriciva Eq a y Ord a se simplificaría a Ord a (todo tipo ordenado es en particular un tipo con igualdad)

9 Ejemplo cua x = x x, sabiendo ( ) :: Num a a a a Decoramos: (cua :: a 1 x :: a 2 ) :: a 3 = (( ) :: Num a 4 a 4 a 4 a 4 x :: a 2 x :: a 2 ) :: a 3 Ecuaciones + Restricciones a 1 = a 2 a 3, a 4 a 4 a 4 = a 2 a 2 a 3 Numa 4 Resolvemos: a 1 = a 2 a 2 a 2, a 3 = a 2, a 4 = a 2 Num (a 2, a 3, a 4 ) Tenemos cua :: Num a 2 :: a 2 a 2 a 2