Modelado algebraico de tipos de datos recursivos

Transcripción

1 Introducción a la Programación Genérica Modelado algebraico de tipos de datos recursivos Modelado algebraico de tipos Tipos de datos recursivos pueden ser definidos en la mayoría de los lenguajes de programación modernos. Ejemplos: Haskell, ML, Java. Veremos como los tipos de datos recursivos son modelados en el lenguaje de categorías. Tal modelado está basado en una visión algebraica de los tipos. Prog. Genérica - InCo 1

2 Declaraciones de tipos de datos La estructura sintáctica de los elementos de un tipo es declarada mediante los constructores del mismo. Los constructores con múltiples argumentos los vamos a considerar en forma no currificada. Es decir, nuestras declaraciones de tipo van a ser de la forma: data T = C 1 (τ 1,1 τ 1,k1 ). C n (τ n,1 τ n,kn ) donde en los τ i,j puede eventualmente ocurrir T. Esto define que, para cada i,. C i : τ i,1 τ i,ki T Prog. Genérica - InCo 2 Ejemplos Naturales data Nat = Zero Succ Nat define que Zero : Nat Succ : Nat Nat Listas data List(A) = Nil Cons (A List(A)) define que Nil : List(A) Cons : A List(A) List(A) Prog. Genérica - InCo 3

3 Σ-álgebras Una forma natural de ver una declaración de tipo es como definiendo un álgebra de términos. Como una primera aproximación al modelado algebraico de tipos, veamos el caso de las álgebras homogeneas con signatura Σ. A través de una signatura Σ se declara un conjunto de símbolos de función. Para cada f Σ, denotaremos por ar(f) la aridad de f (que es un nro. natural). Una Σ-álgebra A está fromada por un conjunto soporte A junto con una función f A : A ar(f) A para cada f Σ. Prog. Genérica - InCo 4 Ejemplos Sea Σ = {e, } tal que ar(e) = 0 y ar( ) = 2. Σ-álgebras concretas: (N, 0, (+)) (Z, 1, ( )) (B, false, ( )) (List(A), Nil, (++)) Sea Σ = {e, i, } tal que ar(e) = 0, ar(i) = 1 y ar( ) = 2. Σ-álgebras concretas: (Z, 0, ( 1), (+)) (N, 1, (+1), ( )) (B, false, ( ), ( )) Prog. Genérica - InCo 5

4 Homomorfismos Homomorfismos son mapeos entre álgebras que preservan la estructura. Un Σ-homomorfismo entre dos Σ-álgebras A y B es una función h : A B entre sus conjuntos soportes tal que, para cada f Σ, h(f A (a 1,..., a ar(f) )) = f B (h(a 1 ),..., h(a ar(f) )) En forma de diagrama: A ar(f) h ar(f) B ar(f) f A A h f B B Prog. Genérica - InCo 6 Ejemplos de homomorfismos Sea Σ = {e, } tal que ar(e) = 0 y ar( ) = 2. La función length : List(A) N, tal que length(nil) = 0 length(l++l ) = length(l) + length(l ) es un homomorfismo entre las álgebras (List(A), Nil, (++)) y (N, 0, (+)). La función ispos : N B, tal que ispos(0) = false ispos(x + y) = ispos(x) ispos(y) es un homomorfismo entre las álgebras (N, 0, (+)) y (B, false, ( )). Prog. Genérica - InCo 7

5 Álgebra de términos Dada una signatura Σ, el conjunto de términos T Σ está definido inductivamente de la siguiente forma: f Σ t 1,..., t n T Σ f(t 1,..., t n ) T Σ donde n = ar(f) T Σ es el conjunto soporte del álgebra de términos T Σ. Funciones del álgebra de términos: para cada f Σ, f T Σ (t 1,..., t ar(f) ) def = f(t 1,..., t ar(f) ) Propiedad universal: Existe un único homomorfismo h : T Σ A entre el álgebra de términos y cualquier otra álgebra A. Prog. Genérica - InCo 8 Signaturas como functores Dada una signatura Σ y un conjunto A cualquiera, podemos considerar la siguiente suma: f Σ Aar(f) la cual resume los dominios de las funciones de cualquier Σ-álgebra con conjunto soporte A. Esta suma puede ser vista como la acción sobre objetos de un functor Σ : Set Set, Σ : A f Σ Aar(f) Prog. Genérica - InCo 9

6 Álgebras y homomorfismos (revistos) Usando el functor Σ es posible empaquetar las funciones de un álgebra A en términos de una sola flecha dada por un análisis de casos. ϕ : ΣA A Un homomorfismo entre dos álgebras ϕ : ΣA A y ψ : ΣB B es una función h : A B tal que ΣA Σh ΣB ϕ ψ A h B Prog. Genérica - InCo 10 F -álgebras y F -homomorfismos Las construcciones anteriores se pueden generalizar para el caso de álgebras heterogeneas (varios conjuntos soportes) y para cualquier functor F : C C sobre una categoría C arbitraria. Una F -álgebra es una flecha h : F A A. Un F -homomorfismo entre dos álgebras h : F A A y h : F B B es una flecha f : A B tal que F A F f F B h A f h B La categoría de F -álgebras, Alg(F ), está formada por F -álgebras como objetos y F -homomorfismos como flechas. Prog. Genérica - InCo 11

7 Ecuaciones de tipo Dada una declaración de tipo data T = C 1 (τ 1,1 τ 1,k1 ). C n (τ n,1 τ n,kn ) es posible derivar un functor F : C C que captura la signatura de dicho tipo: donde τ i,j = τ i,j [A/T ]. F A = n i=1 ( τ i,1 τ i,ki ) El tipo de dato es entonces interpretado como una solución (un punto fijo) de la ecuación de tipo: X = F X. Prog. Genérica - InCo 12 Ejemplo: Naturales data Nat = Zero Succ Nat Signatura: NA = 1 + A, esto es, N = 1 + I. Entonces, Nat = 1 + Nat. Álgebras: h = [h 1, h 2 ] : 1 + A A. Homomorfismos: Para h : NA A y k : NB B, f : A B es tal que 1 id 1 1 A f B k 1 k 2 h 1 A f B h 2 A f B Prog. Genérica - InCo 13

8 Ejemplo: Expresiones aritméticas data Exp = Num Int Add (Exp Exp) Mult (Exp Exp) Signatura: EA = Int + A A + A A, esto es, E = Int + I I + I I. Álgebras: h = [h 1, h 2, h 3 ] : Int + A A + A A A Homomorfismos: Para h : EA A y k : EB B, f : A B es tal que: Int + A 2 + A 2 id Int + f f + f f Int + B 2 + B 2 h A f k B Prog. Genérica - InCo 14 Tipos polimórficos La signatura de tipos de datos polimórficos es capturada por functores F : C C C. El primer argumento corresponde al parámetro del tipo de dato polimórfico. Fijando el primer argumento en un objeto A de C uno obtiene un functor F (A, ) : C C, que denotaremos F A, tal que F A B = F (A, B) F A f = F (id A, f) La ecuación de tipo en este caso es de la forma DA = F (A, DA) donde D es el tipo de dato polimórfico. Prog. Genérica - InCo 15

9 Ejemplo: Listas data List(A) = Nil Cons (A List(A)) Signatura: L A B = 1 + A B, esto es, L A = 1 + A I. Álgebras: h = [h 1, h 2 ] : 1 + A B B Homomorfismos: Para h : L A B B y k : L A C C, f : A B es tal que: 1 + A B id 1 + id A f 1 + A C h B f k C Prog. Genérica - InCo 16 Ejemplo: Árboles binarios data Btree(A) = Leaf A Join (Btree(A) Btree(A)) Signatura: B A C = A + C C, esto es, B A = A + I I. Álgebras: h = [h 1, h 2 ] : A + C C C Homomorfismos: Para h : B A X X y k : B A Y Y, f : X Y es tal que: A + X X id A + f f A + Y Y h X f k Y Prog. Genérica - InCo 17

10 Álgebra inicial Un álgebra es dicha inicial si existe un único homomorfismo entre ella y cualquier otra álgebra. Dada una ecuación de tipo X = F X, denotaremos el álgebra inicial como in F : F µf µf Los constructores son las componentes del álgebra inicial: in F = [C 1,..., C n ] El álgebra inicial corresponde al álgebra de términos. Prog. Genérica - InCo 18 Fold La existencia del álgebra inicial permite asociar un operador recursivo a cada tipo de dato, llamado fold (o catamorfismo). Dada un F -álgebra h : F A A, denotaremos por fold F (h) al único homomorfismo entre in F y h. F T F fold F (h) F A in F T fold F (h) h A Fold sustituye cada constructor por la correspondiente función en el álgebra. Fold corresponde a definiciones por recursión estructural sobre el tipo. Prog. Genérica - InCo 19

11 Ejemplo: Naturales Álgebra inicial: data Nat = Zero Succ Nat in N = [Zero, Succ] : 1 + Nat Nat Para cada h = [h 1, h 2 ] : 1 + A A, fold es la única flecha f = fold N (h) : Nat A tal que f Zero = h 1 f Succ = h 2 f Con elementos, f(zero) = h 1 f(succ(n)) = h 2 (f(n)) Ejemplo: add m = fold N ([λu.m, Succ]) : Nat Nat Prog. Genérica - InCo 20 Ejemplo: Expresiones aritméticas data Exp = Num Int Add (Exp Exp) Mult (Exp Exp) Álgebra inicial: in E = [Num, Add, Mult] : Int+Exp Exp+Exp Exp Exp Para cada h = [h 1, h 2, h 3 ] : Int + A A + A A A, fold es la única flecha f = fold E (h) : Exp A tal que f Num = h 1 f Add = h 2 (f f) f Mult = h 3 (f f) Prog. Genérica - InCo 21

12 Ejemplo: Expresiones aritméticas Con elementos, f(num(n)) = h 1 (n) f(add(e, e )) = h 2 (f(e), f(e )) f(mult(e, e )) = h 3 (f(e), f(e )) Ejemplo: eval = fold E ([id, +, ]) : Exp Int Esto es, eval(num(n)) = n eval(add(e, e )) = eval(e) + eval(e ) eval(mult(e, e )) = eval(e) eval(e ) Prog. Genérica - InCo 22 Ejemplo: Listas Álgebra inicial: in LA = [Nil, Cons] : 1 + A List(A) List(A) Para cada h = [h 1, h 2 ] : 1 + A B B, fold es la única flecha f = fold LA (h) : List(A) B tal que f Nil = h 1 f Cons = h 2 (id A f) Con elementos, f(nil) = h 1 f(cons(a, l)) = h 2 (a, f(l)) Ejemplo: sum = fold LNat ([Zero, add]) : List(Nat) Nat Prog. Genérica - InCo 23

13 Ejemplo: Árboles binarios Álgebra inicial: in BA = [Leaf, Join] : B A Btree(A) Btree(A) Para cada h = [h 1, h 2 ] : A + C C C, fold es la única flecha f = fold BA (h) : Btree(A) C tal que f Leaf = h 1 f Join = h 2 (f f) Con elementos, f(leaf(a)) = h 1 (a) f(join(t, u)) = h 2 (f(t), f(u)) Ejemplo: leaves = fold BA ([wrap, ++]) : Btree(A) List(A) Prog. Genérica - InCo 24 Propiedades del operador fold Ley de identidad: fold F (in F ) = id µf Ley de fusión: f h = h F f f fold F (h) = fold F (h ) En términos de diagramas, F A F f F B µf fold F (h) A h A f h B fold F (h ) f B Prog. Genérica - InCo 25

14 Banana split fold F (h), fold F (k) = fold F ( h F π 1, k F π 2 ) Prog. Genérica - InCo 26 Transformador Un transformador es una función T : (F A A) (GA A) polimórfica en A que construye G-álgebras a partir de F -álgebras. Propiedad: Por ser T polimórfica se cumple que F A F f F B GA Gf GB h h T(h) T(h ) A f B A f B Prog. Genérica - InCo 27

15 Fusión de fold con fold Si T : (F A A) (GA A) es un transformador, entonces fold F (h) fold G (T(in F )) = fold G (T(h)) O sea, fold G (T(h)) = µg fold G(T(in F )) µf fold F (h) A donde h : F A A. Esta propiedad es también conocida como ley de deforestación o ley de la lluvia ácida (acid rain law). Prog. Genérica - InCo 28 Ejemplo Consideremos el tipo de dato data Tree(A) = Empty Node (Tree(A) A Tree(A)) y la función prune : List(A) Tree(A) Tree(A) prune l = p donde p(empty) = Empty p(node(t, a, t )) = if a l then Empty else Node(p(t), a, p(t )) Prog. Genérica - InCo 29

16 Ejemplo (cont.) prune l = fold TA (fprune) donde T A B = 1 + B A B fprune : 1 + Tree(A) A Tree(A) Tree(A) fprune(x) = case x of inl(u) Empty inr(t, a, t ) if a l then Empty else Node(t, a, t ) Prog. Genérica - InCo 30 Ejemplo (cont.) donde fprune = T(in TA ) in TA = [Empty, Node] T : (F A B B) (F A B B) T(h) = λx. case x of inl(u) h 1 inr(b, a, b ) if a l then h 1 else h 2 (b, a, b ) siendo h = [h 1, h 2 ] : 1 + B A B B. T satisface ser un transformador. Prog. Genérica - InCo 31

17 Ejemplo (cont.) size : Tree(A) Int size(empty) = 0 size(node(t, a, t )) = 1 + size(t) + size(t ) size = fold TA (fsize) fsize : 1 + Int A Int Int count : List(A) Tree(A) Int count l = size prune l count l = Tree(A) prune l Tree(A) size Int Prog. Genérica - InCo 32 Ejemplo (cont.) Aplicando fusión de fold con fold se obtiene que count l = fold TA (T(fsize)) o sea, count l Empty = 0 count l (Node(t, a, t )) = if a l then 0 else 1 + count l t + count l t Prog. Genérica - InCo 33

18 Functor de tipo Todo tipo de dato polimórfico D se puede hacer un functor D : C C, llamado functor de tipo, definiendo su acción sobre flechas f : A B, Esto es, Df def = fold FA (in FB F (f, id DB )) : DA DB F A (DA) in FA F A (Df) F A (DB) F (f, id) F B (DB) DA Df DB in FB Prog. Genérica - InCo 34 Ejemplo: Listas Para f : A B, Por lo tanto, List(f) = fold LA ([Nil, Cons (f id)]) List(f)(Nil) = Nil List(f)(Cons(a, l)) = Cons(f(a), List(f)(l)) List corresponde a la popular función map. map :: (a -> b) -> ([a] -> [b]) map f [] = [] map f (x:xs) = f x : map f xs Prog. Genérica - InCo 35

19 Ejemplo: Árboles binarios Para f : A B, Btree(f) = fold BA ([Leaf f, Join]) Esto es, Btree(f)(Leaf(a)) = Leaf(f(a)) Btree(f)(Join(t, u)) = Join(Btree(f)(t), Btree(f)(u)) Prog. Genérica - InCo 36 Rose trees Rose trees son árboles con múltiples ramificaciones: data Rose(A) = Fork(A List(Rose(A))) Signatura: R A B = A List(B), esto es, R A = A List. Álgebras: h : A List(B) B. Álgebra inicial: in RA = Fork : A List(Rose(A)) Rose(A) Para cada h : A List(B) B, fold es la única flecha f = fold RA (h) : Rose(A) B tal que: f(fork(a, l)) = h(a, List(f)(l)) Prog. Genérica - InCo 37

20 unzip genérico gunzip : D(A B) (DA DB) gunzip = D π 1, D π 2 Propiedad: Para toda f : A A y g : B B, D(A B) gunzip DA DB D(f g) D(A B ) Df Dg gunzip DA DB Prog. Genérica - InCo 38 Fusión entre map y fold Para toda f : A B y h : F B C C, fold FB (h) Df = fold FA (h F (f, id C )) Esto es, fold FA (h F (f, id)) = DA Df DB fold F B (h) C Prog. Genérica - InCo 39

21 Ejemplo all : (A Bool) List(A) Bool all p = and List(p) donde and : List(Bool) Bool and = fold LBool ([True, ]) Por la ley de fusión entre map y fold se obtiene que: all p = fold LA ([True, (p id)]) Prog. Genérica - InCo 40 Tipos de datos regulares Un tipo de dato es dicho regular si su declaración no contiene espacios de funciones ( ) y las ocurrencias recursivas del tipo aparecen con los mismos argumentos que en la parte izquierda de la declaración. La signatura de los tipos de datos regulares es modelada por functores regulares: F ::= I A F F F + F D Prog. Genérica - InCo 41

22 Bifunctores regulares La signatura de tipos regulares polimórficos es modelada por bifunctores regulares (functores de tipo C C C): donde F ::= C U Par Rec F F F + F DF C = Nat, Int, Bool, String, etc. U = 1 P ar = Π 1 (extrae el parámetro) Rec = Π 2 (extrae el parámetro recursivo) Prog. Genérica - InCo 42 Ejemplos de bifunctores L(A, X) = 1 + A X L = U + Par Rec B(A, X) = A + X X B = Par + Rec Rec T (A, X) = 1 + X A X T = U + Rec Par Rec R(A, X) = A List(X) R = Par List Rec Prog. Genérica - InCo 43