9 DECLARACIÓN DE TIPOS Y PATRONES

Transcripción

1 9 DECLARACIÓN DE TIPOS Y PATRONES Aunque los tipos de datos predefinidos en Ocaml permiten la construcción de estructuras de datos a partir de tuplas y listas, normalmente es necesario definir nuevos tipos de datos para describir ciertas estructuras de datos. En Ocaml, las definiciones de tipos son recursivas y pueden estar parametrizadas mediante el uso de variables de tipo, como las usadas en el tipo a list que hemos revisado anteriormente. La inferencia de tipos toma en cuenta estas declaraciones para producir el tipo final de las expresiones. Una característica especial de la familia de lenguajes ML es el uso de patrones y la correspondencia entre ellos como mecanismo de control. La definición de una función se puede especificar como un caso de correspondencia entre patrones sobre uno de sus parámetros, permitiendo una definición basada en casos. Presentaremos el mecanismo de correspondencia de patrones sobre los tipos predefinidos en el lenguaje y posteriormente describiremos como declarar tipos estructurados y como construir valores de tales tipos, así como la forma de acceder a sus componentes mediante correspondencia de patrones.. Un patrón no es estrictamente hablando una expresión de OCaml, sino una forma adecuada de acomodar elementos del lenguaje, como los constructores del mismo, las variables y el símbolo _ llamado comodín. La correspondencia entre patrones se aplica a valores. Se usa para reconocer la forma de un valor y guiar la computación de acuerdo con esta forma, asociando a cada forma posible del valor, una expresión a evaluar. Su forma general es: 1 match expr with 2 p_1 -> expr_ p_n -> expr_n donde el valor expr es comparado secuencialmente con los patrones p 1.p n y el patrón p i es consistente con el valor de expr, entonces la expresión expr i es evaluada. Los patrones p i, evidentemente, son del mismo tipo. Lo mismo ocurre con las expresiones expr i. La barra que precede el primer caso es opcional. Ejemplo 29 Por ejemplo, la definición de la implicación con signatura bool bool! bool, es: 1 # let implica v = match v with 2 (true,true) -> true 3 (true,false) -> false 4 (false,true) -> true 5 (false,false) -> false;; 117

2 118 6 val implica : bool * bool -> bool = <fun> Usando variables que agrupen varios casos, es posible obtener una definición más compacta de implicación: 1 # let implica2 v = match v with 2 (true,x) -> x 3 (false,x) -> false;; 4 val implica2 : bool * bool -> bool = <fun> Las dos versiones de implica computan la misma función, es decir, regresan el mismo valor para entradas iguales. Patrones lineales Un patrón necesita ser lineal, esto es, ninguna variable dada puede ocurrir más de una vez dentro del patrón bajo correspondencia. Por ello, el siguiente ejemplo conduce al error indicado. Ejemplo 30 Ejemplo de un error por no linealidad en el patrón bajo correspondencia: 1 # let igual c = match c with 2 (x,x) -> true 3 (x,y) -> false ;; 4 Characters 34-35: 5 (x,x) -> true 6 ^ 7 Error: Variable x is bound several times in this matching El código anterior fuese correcto si el compilador de OCaml entendiera el concepto de prueba de igualdad, pero esto acarrea normalmente muchos problemas. Por ejemplo, si aceptamos un criterio de igualdad física entre valores, obtenemos un sistema demasiado débil como para reconocer la igualdad entre dos ocurrencias de la lista [1; 2] (como ocurre de hecho con eq en Lisp). Por otro lado, las pruebas de igualdad estructural, nos pueden llevar a la construcción de valores no funcionales recursivos. Ejemplo 31 Ejemplo de valor no funcional recursivo. Una lista circular con un elemento: 1 # let rec l = 1::l ;; 2 val l : int list = 3 [1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1;.] que conlleva a recorrer indefinidamente el valor para intentar verificar la igualdad y fallar por desbordamiento de memoria.

3 . 119 Patrones con comodines El símbolo _ se corresponde con todos los valores posibles y se conoce como comodín. Puede usarse para buscar correspondencias con tipos complejos, por ejemplo, estructuras circulares. Si queremos simplificar aún más la definición de implica podemos usar el comodín de la siguiente manera: Ejemplo 32 Una simplificación más de la implicación usando comodines: 1 # let implica3 v = match v with 2 (true,false) -> false 3 _ -> true;; 4 val implica3 : bool * bool -> bool = <fun> La definición de una correspondencia entre patrones debe cubrir el conjunto completo de posibles valores bajo la correspondencia. Si este no es el caso, el compilador nos advierte de ello. 1 # let es_cero n = match n with 0 -> true ;; 2 Characters 16-38: 3 let es_cero n = match n with 0 -> true ;; 4 ^^^^^^^^^^^^^^^^^^^^^^ 5 Warning P: this pattern-matching is not exhaustive. 6 Here is an example of a value that is not matched: val es_cero : int -> bool = <fun> El comodín puede usarse en este caso para completar los casos a revisar: 1 # let es_cero n = match n with 2 0 -> true 3 _ -> false ;; 4 val es_cero : int -> bool = <fun> Ocaml ofrece otro mecanismo de seguridad para el caso de definiciones de correspondencia entre patrones no exhaustiva. En caso de que ningún patrón haya sido seleccionado, el compilador genera una excepción. Revisen las siguientes evaluaciones: 1 # let f x = match x with 0 -> 1 ;; 2 Characters 10-29: 3 let f x = match x with 0 -> 1 ;; 4 ^^^^^^^^^^^^^^^^^^^ 5 Warning P: this pattern-matching is not exhaustive. 6 Here is an example of a value that is not matched: val f : int -> int = <fun> 9 # f 0 ;; 10 - : int = 1 11 # f 1 ;; 12 Exception: Match_failure ("", 15, -33).

4 120 Como la excepción no ha sido manejada en el programa, la computación en curso se detiene. Combinando patrones Es posible combinar patrones para obtener un nuevo patrón, siempre y cuando estos patrones no impliquen nombres. De forma que cada uno de ellos debe incluir únicamente valores constantes y comodines. Consideren el siguiente ejemplo: Ejemplo 33 Un predicado es_vocal definido usando combinación de patrones: 1 # let es_vocal x = match x with 2 a e i o u -> true 3 _ -> false;; 4 val es_vocal : char -> bool = <fun> Correspondencia entre patrones de un parámetro Como la correspondencia entre patrones puede facilitarnos definir una función basados en casos, el constructor function nos permite hacer correspondencia de patrones sobre parámetros. De echo la forma: 1 function p_1 -> expr_1. p_n -> expr_n ;; es equivalente a la forma: 1 function expr -> match expr with 2 p_1 -> expr_ p_n -> expr_n ;; Nombrando valores bajo correspondencia La palabra reservada as, nos permite nombrar valores bajo la correspondencia de patrones. Consideren el siguiente ejemplo. Ejemplo 34 La función min_rat regresa el menor de dos números racionales. Su definición usa valores nombrados en la correspondencia de patrones: 1 # let min_rat pr = match pr with 2 ((_,0),p2) -> p2 3 (p1,(_,0)) -> p1 4 (((n1,d1) as r1), ((n2,d2) as r2)) -> 5 if (n1*d2) < (n2*d1) then r1 else r2;; 6 val min_rat : (int * int) * (int * int) -> int * int = <fun> así podemos computar que es más pequeño, un medio o un tercio:

5 # min_rat ((1,3),(1,2)) ;; 2 - : int * int = (1, 3) Correspondencia de patrones con guardias Las guardias se usan para implementar evaluaciones condicionadas justo después de llevarse a cabo la correspondencia de patrones. Si la expresión que define la guardia regresa true, entonces la expresión asociada al patrón es evaluada. Para definir guardias se utiliza la palabra reservada when. Ejemplo 35 La función de igualdad entre racionales hace uso de dos guardias. 1 # let igual_rat pr = match pr with 2 ((_,0),(_,0)) -> true 3 ((_,0),_) -> false 4 (_,(_,0)) -> false 5 ((n1,1),(n2,1)) when n1 = n2 -> true 6 ((n1,d1),(n2,d2)) when (n1*d2)=(n2*d1) -> true 7 _ -> false;; 8 val igual_rat : (int * int) * (int * int) -> bool = <fun> de forma que podemos computar si un medio y dos cuartos son iguales: 1 # igual_rat ((1,2),(2,4)) ;; 2 - : bool = true Si la guardia falla, por ejemplo en el cuarto patrón, la correspondencia de patrones continua con los siguientes casos.. Otro ingrediente posible en los programas Ocaml es la definición de tipos. Hay dos grandes familias de tipos: los tipos producto para tuplas o registros; y los tipos suma para las uniones. La palabra reservada para definir tipos es type y, al contrario que la definición de variables, estas declaraciones son recursivas por defecto. Esto es, cuando se combinan declaraciones de tipos, se pueden usar declaraciones de tipos mutuamente recursivas. Es posible parametrizar las declaraciones de tipo usando variables de tipo. Recuerden que el nombre de una variable de tipo siempre comienza con apóstrofo. Si se necesitan varios parámetros en la declaración, estos pueden incluirse como una tupla. Siempre es posible definir un tipo a partir de otro u otros ya existentes. Esto es útil para especializar un tipo de datos que resulta ser demasiado general. Ejemplo 36 Especializando un tipo demasiado general. 1 # type parametro par_con_entero = int * parametro ;;

6 122 2 type a par_con_entero = int * a 3 # type par_especifico = float par_con_entero ;; 4 type par_especifico = float par_con_entero Sin embargo sin restricciones de tipo, la inferencia computa el tipo más general. Usando restricciones se puede obtener el tipo deseado. 1 # let x = (3,3.14) ;; 2 val x : int * float = (3, 3.14) 3 # let (x:par_especifico) = 3,3.14 ;; 4 val x : par_especifico = (3, 3.14) Registros o tipos producto Los registros su tuplas en donde cada uno de sus componentes tiene nombre, como los registros en Pascal o las estructuras en C. Un registro siempre corresponde a la declaración de un nuevo tipo. La declaración de un tipo se define mediante la declaración de su nombre y de los nombres y tipos de cada uno de sus campos. Ejemplo 37 Definición del registro complejo. 1 # type complejo = {re:float; im:float} ;; 2 type complejo = { re : float; im : float; } La creación de un valor del registro se realiza dando valor a cada uno de sus componentes, posiblemente en orden arbitrario. 1 # let c = {re=2.;im=3.};; 2 val c : complejo = {re = 2.; im = 3.} El acceso a los componentes de un registro puede llevase a cabo usando la notación punto, usual en otros lenguajes; o bien mediante la correspondencia entre patrones. Ejemplo 38 Multiplicación y suma de complejos, la primer función usa notación punto, la segunda correspondencia entre patrones. 1 # let suma_complejos c1 c2 = 2 {re= c1.re+.c2.re; im= c1.im+.c2.im};; 3 val suma_complejos : complejo -> complejo -> complejo = <fun> 4 # let mult_complejos c1 c2 = match (c1,c2) with 5 ({re=x1;im=y1},{re=x2;im=y2}) -> 6 {re= x1*.x2-.y1*.y2; im= x1*.y2+.x2*.y1};; 7 val mult_complejos : complejo -> complejo -> complejo = <fun> 8 # suma_complejos c c ;; 9 - : complejo = {re = 4.; im = 6.} 10 # mult_complejos c c ;; 11 - : complejo = {re = -5.; im = 12.}

7 . 123 Las ventajas de registros con respecto a las tuplas son: información descriptiva y distintiva gracias a los nombres de los campos, lo que permite simplificar la correspondencia entre patrones; y el acceso uniforme a los campos, mediante el nombre. Esto es, el orden de los campos ya no son significantes, sólo los nombres cuentan. Ejemplo 39 Los ejemplos siguientes muestran la simplificación para acceder a los campos en registros, con respecto a las tuplas. 1 # let a = (1,2,3) ;; 2 val a : int * int * int = (1, 2, 3) 3 # let f tr = match tr with x,_,_ -> x ;; 4 val f : a * b * c -> a = <fun> 5 # f a ;; 6 - : int = 1 7 # type triplete = {x1:int; x2:int; x3:int} ;; 8 type triplete = { x1 : int; x2 : int; x3 : int; } 9 # let b = {x1=1; x2=2; x3=3} ;; 10 val b : triplete = {x1 = 1; x2 = 2; x3 = 3} 11 # let g tr = tr.x1 ;; 12 val g : triplete -> int = <fun> 13 # g b ;; 14 - : int = 1 Existe una construcción que permite crear un registro idéntico a otro con excepción de algunos campos. Ejemplo 40 Creación de registros cuasi idénticos. 1 # let c = {b with x1=0} ;; 2 val c : triplete = {x1 = 0; x2 = 2; x3 = 3} Tipos suma A diferencia de las tuplas o registros, que se corresponden con los productos cartesianos, la declaración de tipos suma se corresponde con la unión entre conjuntos. Diferentes tipos, por ejemplo enteros y cadenas, pasan a formar un sólo tipo. Los diferentes miembros de la suma se distinguen mediante constructores especializados y correspondencia entre patrones para el acceso a los componentes. Un tipo suma se define dando los nombres de sus constructores (que siempre inician con mayúscula) y los tipos de sus eventuales argumentos. Constructores constantes Un constructor que no espera argumentos se conoce como constructor constante. Este tipo de constructor puede usarse directamente como un valor constante en el lenguaje. Ejemplo 41 Constructores constantes para volados.

8 124 1 # type volado = Aguila Sol ;; 2 type volado = Aguila Sol 3 # Sol ;; 4 - : volado = Sol Evidentemente, el tipo bool puede definirse de esta manera. Constructores con argumentos Los constructores pueden tener argumentos. La palabra reservada of indica el tipo de los argumentos de los constructores. Ejemplo 42 Carta de baraja como tipos suma. 1 # type palo = Oros Copas Espadas Bastos;; 2 type palo = Oros Copas Espadas Bastos 3 # type carta = 4 As of palo 5 Rey of palo 6 Caballo of palo 7 Sota of palo 8 Carta_menor of palo * int;; 9 type carta = 10 As of palo 11 Rey of palo 12 Caballo of palo 13 Sota of palo 14 Carta_menor of palo * int La creación de valores de tipo carta se lleva a cabo mediante la aplicación de constructores a valores de un tipo apropiado. 1 # Rey Oros ;; 2 - : carta = Rey Oros 3 # Carta_menor(Oros,2) ;; 4 - : carta = Carta_menor (Oros, 2) A continuación definiremos una función que lista todas las cartas de un palo dado, pasado como parámetro. 1 # let rec intervalo a b = 2 if a = b then [b] else 3 a::(intervalo (a+1) b);; 4 val intervalo : int -> int -> int list = <fun> 5 # intervalo 2 7 ;; 6 - : int list = [2; 3; 4; 5; 6; 7] 7 # let todas_las_cartas p = 8 let figuras = [As p; Rey p; Caballo p; Sota p ] 9 and otras = List.map (function n -> Carta_menor(p,n)) 10 (intervalo 2 7)

9 in otras;; 12 val todas_las_cartas : palo -> carta list = <fun> 13 # todas_las_cartas Bastos ;; 14 - : carta list = 15 [As Bastos; Rey Bastos; Caballo Bastos; Sota Bastos; 16 Carta_menor (Bastos, 2); Carta_menor (Bastos, 3); 17 Carta_menor (Bastos, 4); Carta_menor (Bastos, 5); 18 Carta_menor (Bastos, 6); Carta_menor (Bastos, 7)] Para manejar los valores de los tipos suma usamos correspondencia entre patrones. Ejemplo 43 Convertidores de carta y palo a cadenas de caracteres mediante correspondencia entre patrones. 1 # let string_of_palo = function 2 Oros -> "oros" 3 Copas -> "copas" 4 Espadas -> "espadas" 5 Bastos -> "bastos";; 6 # let string_of_carta = function 7 As c -> "as de " ^ (string_of_palo c) 8 Rey c -> "rey de " ^ (string_of_palo c) 9 Caballo c -> "caballo de " ^ (string_of_palo c) 10 Sota c -> "sota de " ^ (string_of_palo c) 11 Carta_menor (c,n) -> (string_of_int n) ^ 12 " de " ^ (string_of_palo c);; 13 val string_of_carta : carta -> string = <fun> 14 # string_of_carta (Rey Oros) ;; 15 - : string = "rey de oros" 16 # string_of_carta (Carta_menor (Espadas,3)) ;; 17 - : string = "3 de espadas" Ahora definiremos es_carta_menor usando correspondencia entre patrones: 1 # let es_carta_menor = function 2 Carta_menor _ -> true 3 _ -> false;; 4 val es_carta_menor : carta -> bool = <fun> 5 # es_carta_menor (Carta_menor (Oros,2)) ;; 6 - : bool = true 7 # es_carta_menor (Rey Bastos) ;; 8 - : bool = false Tipos recursivos Los tipos de datos recursivos son indispensables en un lenguaje de programación para describir las estructuras de datos con las que solemos trabajar (listas, pilas, arboles, grafos, etc.). Es por ello que type es por defecto recursivo, al contrario de la declaración de tipos con let. Las listas en Ocaml toman argumentos de un solo tipo (su valor funcional es a list. Si queremos guardar valores de diferentes tipos en una lista, podemos usar un tipo suma recursivo.

10 126 Ejemplo 44 Listas de enteros y caracteres como tipo recursivo 1 # type lista_de_int_y_char = 2 Nil 3 Int_cons of int * lista_de_int_y_char 4 Char_cons of char * lista_de_int_y_char ;; 5 # Char_cons( a,int_cons(5,nil)) ;; 6 - : lista_de_int_y_char = Char_cons ( a, Int_cons (5, Nil)) Tipos recursivos parametrizados Podemos parametrizar la definición anterior para generalizar el concepto de listas de elementos de dos tipos diferentes. Ejemplo 45 Listas de dos tipos diferentes. 1 # type ( a, b) lista_dos_tipos = 2 Nil 3 Acons of a * ( a, b) lista_dos_tipos 4 Bcons of b * ( a, b) lista_dos_tipos;; 5 type ( a, b) lista_dos_tipos = 6 Nil 7 Acons of a * ( a, b) lista_dos_tipos 8 Bcons of b * ( a, b) lista_dos_tipos 9 # Acons(2, Bcons( +, Acons(3,Nil))) ;; 10 - : (int, char) lista_dos_tipos = Acons (2, Bcons ( +, Acons (3, Nil ))) 11 # Acons("Hola",Bcons(1, Nil)) ;; 12 - : (string, int) lista_dos_tipos = Acons ("Hola", Bcons (1, Nil)). Ejemplifiquemos los conceptos de este capítulo con la definición del tipo de datos arbol_binario y sus operaciones. Primero definiremos el tipo de datos siguiendo la definición usual de un árbol binario: Un árbol es un nodo vacío o un nodo interno en cuyo caso tiene dos hijos que a su vez son árboles binarios. 1 # type a arbol_binario = 2 Vacio 3 Nodo of a arbol_binario * a * a arbol_binario;; 4 type a arbol_binario = 5 Vacio 6 Nodo of a arbol_binario * a * a arbol_binario 7 # Nodo(Vacio,1,Vacio) ;; 8 - : int arbol_binario = Nodo (Vacio, 1, Vacio) Primero escribiremos una función para extraer una lista de la información en los nodos de un árbol binario. La lista estará ordenada si inducimos un recorrido transversal del árbol.

11 # let rec lista_de_arbol = function 2 Vacio -> [] 3 Nodo(l,e,r) -> (lista_de_arbol 4 (e :: (lista_de_arbol r));; 5 val lista_de_arbol : a arbol_binario -> a list = <fun> 6 # lista_de_arbol (Nodo (Nodo (Nodo (Vacio, 1, Vacio), 2, Vacio), 7 3, Vacio)) ;; 8 - : int list = [1; 2; 3] Ahora escribiremos una función para crear un árbol binario ordenado a partir de una lista: 1 # let rec inserta x = function 2 Vacio -> Nodo(Vacio,x,Vacio) 3 Nodo(l,e,r) -> if x < e then Nodo(inserta x l, e, r) 4 else Nodo(l,e,inserta x r);; 5 val inserta : a -> a arbol_binario -> a arbol_binario = <fun > 6 # let rec arbol_de_lista = function 7 [] -> Vacio 8 c::r -> inserta c (arbol_de_lista r);; 9 val arbol_de_lista : a list -> a arbol_binario = <fun> 10 # arbol_de_lista [1;2;3;4;5] ;; 11 - : int arbol_binario = 12 Nodo 13 (Nodo (Nodo (Nodo (Nodo (Vacio, 1, Vacio), 2, Vacio), 14 3, Vacio), 4, Vacio), 5, Vacio) 15 # arbol_de_lista [2;1;3;5;4] ;; 16 - : int arbol_binario = 17 Nodo (Nodo (Nodo (Vacio, 1, Nodo (Vacio, 2, Vacio)), 3, Vacio), 4, 18 Nodo (Vacio, 5, Vacio)) Ahora si queremos definir ordena usando las definiciones anteriores tenemos que: 1 # let ordena x = lista_de_arbol(arbol_de_lista x);; 2 val ordena : a list -> a list = <fun> 3 # ordena [5;2;3;6;7;1;4;8] ;; 4 - : int list = [1; 2; 3; 4; 5; 6; 7; 8]