Definiciones de tipo. Sinónimos de tipo

Transcripción

1 Capítulo 4. Definiciones de tipo 40 Definiciones de tipo Sinónimos de tipo Un sinónimo de tipo renombra un tipo existente. El nuevo nombre y el antiguo son totalmente intercambiables. type Entero =Integer type DeEnteroEnEntero =Entero Entero uno :: Entero uno = 1 sucesor :: DeEnteroEnEntero sucesor x = x + 1 type ParFlotantes = (Float, Float) parceros :: ParFlotantes parceros = (0.0, 0.0) Un sinónimo de tipo muy usado, definido en Prelude, es String: type String = [Char] nombre :: String nombre = [ p, e, p, e ] nombreyapellidos :: String nombreyapellidos = Jośe E. Gallardo Main> length nombre 4 :: Int16 :: Int Main> length nombreyapellidos 16 :: Int

2 Capítulo 4. Definiciones de tipo 41 Definiciones de tipos de datos El programador puede definir nuevos tipos. Tipos enumerados Haskell permite usar los constructores de datos como patrones: esfinsemana :: DíaSemana Bool esfinsemana Sábado = True esfinsemana Domingo = True esfinsemana = False data DíaSemana = Lunes Martes Miércoles Jueves Viernes Sábado Domingo undía :: DíaSemana undía = Lunes laborables :: [DíaSemana] laborables = [Lunes, Martes, Miércoles, Jueves, Viernes] DíaSemana es un constructor de tipo Lunes, Martes,... son constructores de datos Un constructor de dato también puede ser simbólico, y en ese caso debe ser un operador que comience por el carácter dos puntos : Un mismo constructor de dato no puede aparecer en dos tipos distintos en un mismo ámbito. data Dirección = Norte Sur Este Oeste girar 90 :: Dirección Dirección girar 90 Norte = Este girar 90 Sur = Oeste girar90 Este = Sur girar 90 Oeste = Norte data ColorSemáforo = Rojo Verde Amarillo En Prelude data Bool = False True deriving (Eq, Ord, Ix, Enum, Read, Show, Bounded)

3 Capítulo 4. Definiciones de tipo 42 Uniones Podemos definir nuevos tipos uniendo dos tipos existentes: data LetraOEntero = Letra Char Entero Integer unvalor :: LetraOEntero unvalor = Letra x otrovalor :: LetraOEntero otrovalor = Entero 15 Es incorrecto: data LetraOEntero = Char Integer Temperaturas expresadas en dos escalas: Incorrecto!!! data Temp = Centígrado Float Fahrenheit Float estácongelado :: Temp Bool estácongelado (Centígrado grados) = grados 0.0 estácongelado (Fahrenheit grados) = grados 32.0 listamixta :: [LetraOEntero] listamixta = [ Letra a, Entero 10, Entero 12, Letra b ] Cada constructor de dato tiene un tipo. Letra :: Char LetraOEntero Entero :: Integer LetraOEntero incloe :: LetraOEntero LetraOEntero incloe (Entero n) = Entero. (+1) $ n incloe (Letra c) = Letra. chr. (+1). ord $ c Main> incloe (Letra a ) Letra b :: LetraOEntero Main> incloe (Entero 10) Entero 11 :: LetraOEntero

4 Capítulo 4. Definiciones de tipo 43 Productos También es posible definir tipos con un único constructor y varias componentes: data Racional = Par Integer Integer El constructor en este caso tiene el tipo Par :: Integer Integer Racional unmedio :: Racional unmedio = Par 1 2 Usando patrones podemos definir operaciones para trabajar con racionales: numerador numerador (Par x denominador denominador (Par :: Racional Integer ) = x :: Racional Integer y) = y por :: Racional Racional Racional (Par a b) por (Par c d) = Par (a c) (b d) Main> (Par 1 2) por (Par 1 3) Par 1 6 :: Racional Nombre, apellidos y edad de una persona: type Nombre =String type Apellido1 =String type Apellido2 =String type Edad =Integer data Persona =UnaPersona Nombre Apellido1 Apellido2 Edad pepe :: Persona pepe = UnaPersona Jośe Pérez Sánchez 18 Haskell permite nombrar las distintas componentes de un tipo: type Nombre =String type Apellido =String type Edad =Integer data Persona =UnaPersona { nombre :: Nombre, apellido1 :: Apellido, apellido2 :: Apellido, edad :: Edad }

5 Capítulo 4. Definiciones de tipo 44 Con registros, los datos se pueden declarar con la sintaxis habitual o nombrando los campos: pepe :: Persona pepe = UnaPersona Jośe Pérez Sánchez 18 juan :: Persona juan = UnaPersona { nombre = Juan, apellido1 = López, apellido2 = Giménez, edad =24 } Además, se introducen automáticamente funciones selectoras para las componentes: Main> : t edad edad :: Persona Edad Main> edad juan 24 :: Integer Se puede construir un nuevo valor a partir de otro existente, indicando el valor de las componentes que defieren: Main> juan {apellido1 = Boj, apellido2 = Sanz } UnaPersona {nombre = Juan, apellido1 = Boj, apellido2 = Sanz, edad = 24} :: Persona Lo cual, por supuesto, no afecta para nada al valor de juan: Main> juan UnaPersona {nombre = Juan, apellido1 = López, apellido2 = Giménez, edad = 24} :: Persona La siguiente función devuelve una nueva Persona con la edad incrementada: cumpleaños :: Persona Persona cumpleaños p = p {edad = edad p + 1} Main> cumpleaños juan UnaPersona{nombre = Juan, apellido1 = López, apellido2 = Giménez, edad = 25} :: Persona

6 Capítulo 4. Definiciones de tipo 45 Los identificadores de constructores binarios de dato también pueden ser simbólicos Siempre han de comenzar por el carácter dos puntos data Complejo =Float : Float origen :: Complejo origen = 0.0 : 0.0 partereal partereal (x : :: Complejo Float ) = x El constructor de dato introducido tiene el siguiente tipo: (: ) :: Float Float Complejo Main> (: ) : 2.0 :: Complejo Main> 1.0 : : 2.0 :: Complejo Un constructor literal puede usarse de forma infija si se escribe entre acentos franceses: dostercios :: Racional dostercios = 2 Par 3 También es posible definir registros variantes Un tipo que representa cuatro clases de figuras: type Radio =Float type Lado =Float data Figura = C írculo Radio Cuadrado Lado Rectángulo Lado Lado Punto unc írculo :: Figura unc írculo = C írculo 25.0 unrectángulo :: Figura unrectángulo = Rectángulo listafiguras :: [Figura] listafiguras = [C írculo 15.0, Cuadrado 3.0, Rectángulo ] Define dos funciones para calcular el área y per ímetro de una Figura.

7 Capítulo 4. Definiciones de tipo 46 Tipos recursivos Haskell permite la definición de tipos infinitos mediante declaraciones de tipos recursivos. Los naturales El cero es un número natural. Si n es un número natural, entonces n + 1 también lo es. En Haskell la declaración es: data Nat = Cero Suc Nat Cero :: Nat Suc :: Nat Nat Algunas funciones uno :: Nat uno = Suc Cero dos :: Nat dos = Suc (Suc Cero) puede escribirse Suc uno Cero, Suc Cero, Suc (Suc Cero),... los llamaremos valores definidos. Existen otros valores del tipo que no representan ningún número natural. undefined :: a undefined False = undefined siempre falla indefinidon :: Nat indefinidon = undefined Main> uno Suc Cero :: Nat Main> dos Suc (Suc Cero) :: Nat Main> indefinidon Program error : undefined Este valor suele denotarse semánticamente como (se lee bottom). Se considera que las evaluaciones que producen algún error o que no terminan (divergen) se reducen a. indefinidon =. Main> Suc indefinidon Suc Program error : undefined Main> Suc (Suc indefinidon ) Suc (Suc Program error : undefined

8 Capítulo 4. Definiciones de tipo 47 Obsérvese que dan lugar a evaluaciones distintas. Así, Suc indefinidon = Suc mientras que Suc (Suc indefinidon ) = Suc (Suc ) Suc indefinidon está algo más definido que indefinidon. escero :: Nat Bool escero Cero = True escero = False Main> escero indefinidon Program error : undefined Main> escero (Suc indefinidon ) False :: Bool infiniton :: Nat infiniton = Suc infiniton Main> infiniton Suc (Suc (Suc (Suc (Suc (Suc (Suc (Suc {Interrupted!} La siguiente función comprueba si un valor de tipo Nat representa un número par: espar :: Nat Bool espar Cero = True espar (Suc x) = not (espar x) El siguiente operador calcula la suma de dos valores del tipo Nat, analizando la forma del segundo argumento: infixl 6 <+> (<+>) :: Nat Nat Nat m <+> Cero = m m <+> (Suc n) = Suc (m <+> n) uno <+> dos =! definición de dos uno <+> Suc (Suc Cero) =! segunda ecuación de (<+>) Suc (uno <+> (Suc Cero)) =! segunda ecuación de (<+>) Suc (Suc (uno <+> Cero)) =! primera ecuación de (<+>) Suc (Suc (uno)) =! definición de uno Suc (Suc (Suc Cero))

9 Capítulo 4. Definiciones de tipo 48 En general, si una función tiene más de un argumento recursivo, podemos intentar realizar la recursión sobre uno de ellos. infixl 6 <+> (<+>) :: Nat Nat Nat Cero <+> n = n (Suc m) <+> n = Suc (m <+> n) No siempre es posible realizar la definición sobre cualquiera de los argumentos. Para el tipo Nat también es posible definir el producto y la potencia: infixl 7 < > (< >) :: Nat Nat Nat m < > Cero = Cero m < > (Suc n) = m < > n <+> m infixr 8 < > ya que m (n + 1) = m n + m (< >) :: Nat Nat Nat b < > Cero = Suc Cero b < > (Suc n) = b < > b < > n Expresiones aritméticas simples sobre enteros: data Expr = Valor Integer Expr :+: Expr Expr : : Expr Expr : : Expr Calcular el número de operadores que forman parte de una expresión: numopers :: Expr Integer numopers (Valor ) = 0 numopers (e1 :+: e2) = numopers e numopers e2 numopers (e1 : : e2) = numopers e numopers e2 numopers (e1 : : e2) = numopers e numopers e2 Define una función que calcule el valor de una expresión. Define una función que calcule cuántas constantes enteras aparecen en una expresión. Define una función que calcule el nivel de anidamiento máximo de un operador en una expresión. ya que b (n + 1) = b b n

10 Capítulo 4. Definiciones de tipo 49 Funciones de plegado Para cada tipo recursivo es posible definir un recursor de plegado. Muchas de las funciones definidas sobre el tipo Nat siguen un mismo patrón recursivo. Recordemos algunas: data Nat = Cero Suc Nat espar :: Nat Bool espar Cero = True espar (Suc n) = not (espar n) (<+>) :: Nat Nat Nat (<+>) m Cero = m (<+>) m (Suc n) = Suc (m <+> n) Siguen la plantilla: fun :: Nat a fun Cero = e fun (Suc n) = f (fun n) Función de plegado para el tipo Nat foldnat :: (a a) a Nat a foldnat f e Cero = e foldnat f e (Suc n) = f (foldnat f e n) Entonces: espar = foldnat not True (<+>) m =foldnat Suc m Comportamiento de foldnat foldnat h z (Suc (Suc ( i. veces.. (Suc Cero)))) = h (h ( i. veces.. h z)) espar (Suc (Suc Cero)) =! por definición de espar foldnat not True (Suc (Suc Cero)) =! por segunda ecuación de foldnat... True Escribe una función de plegado para el tipo Expr data Expr = Valor Integer Expr :+: Expr Expr : : Expr Expr : : Expr

11 Capítulo 4. Definiciones de tipo 50 Tipos Parametrizados (o Polimórficos) Algunos tipos predefinidos (como las listas) son polimórficos. Otro ejemplo: data Par a = UnPar a a (a es una variable de tipo). Main> UnPar 1 2 UnPar 1 2 :: Par Integer Main> UnPar True False UnPar True False :: Par Bool Main> UnPar a True ERROR : Type error in application Expression : UnPar a True Term : a Type : Char Does not match : Bool El tipo Either data Either a b = Left a Right b deriving (Eq, Ord, Read, Show) listamixta :: [Either Char Integer] listamixta = [Left a, Left c, Right 3, Left z ] otra :: [Either Bool Char] otra = [Left True, Right a, Right c ] El tipo Maybe data Maybe a = Nothing Just a deriving (Eq, Ord, Read, Show) recíproco :: Float Maybe Float recíproco 0 = Nothing recíproco x = Just (1/x) Main> recíproco Just :: Maybe Float Main> recíproco 0 Nothing :: Maybe Float

12 Capítulo 4. Definiciones de tipo 51 Definiciones newtype La declaración newtype crea un nuevo tipo isomorfo (con los mismos valores) a uno existente, pero con una identidad propia para el sistema de tipos. newtype Natural = UnNatural Integer Todo lo dicho para data vale para newtype. newtype evita el nivel extra de indirección (causado por la evaluación perezosa) que la declaración data introduciría. Las declaraciones newtype usan la misma sintaxis que las declaraciones data que poseen un único constructor con un único campo.

13 Capítulo 4. Definiciones de tipo 52 Propiedades de funciones Podemos entender mejor el significado de un programa estableciendo propiedades de las funciones que lo forman. Algunas propiedades pueden probarse directamente a partir de la definiciones de las funciones involucradas. Demostrar que la composición de funciones es asociativa (.) :: (b c) (a b) (a c) g. f = λ x g (f x) Asociatividad de (.) v ((f 1. f 2 ). f 3 ) v = (f 1. (f 2. f 3 )) v ((f 1. f 2 ). f 3 ) v! por definición de (.) (f 1. f 2 ) (f 3 v)! por definición de (.) f 1 (f 2 (f 3 v)) Transformamos ahora la parte derecha: f 1 ((f 2. f 3 ) v)! por definición de (.) f 1 (f 2 (f 3 v)) con lo cual queda demostrada la proposición original. Para tipos enumerados podemos probar la propiedad en cada caso not :: Bool Bool not True = False not False = True Doble negación x :: Bool not (not x) = x Si x es True, hay que probar not (not True) = True. not (not True)! por definición de not not False! por definición de not True Si x es False,... (f 1. (f 2. f 3 )) v! por definición de (.)

14 Capítulo 4. Definiciones de tipo 53 Las declaraciones de tipo recursivas dan lugar a conjuntos infinitos. La inducción es la técnica ideal para probar propiedades de funciones que actúan sobre tipos recursivos. El principio de inducción para el tipo Nat: data Nat = Cero Suc Nat Principio de inducción para valores definidos del tipo Nat P (Cero) x :: Nat P(x) x :: Nat P (x) P (Suc x) P Cero (demostrado en caso base)! por paso inductivo P (Suc Cero)! por paso inductivo P (Suc (Suc Cero)) las dos condiciones del principio de inducción son suficientes!! Este principio de inducción no es válido para valores del tipo Nat parcialmente definidos (como indefinidon e infiniton ).

15 Capítulo 4. Definiciones de tipo 54 Para el operador suma, (<+>) :: Nat Nat Nat m <+> Cero = m m <+> (Suc n) = Suc (m <+> n) Cero es neutro por la izquierda: x :: Nat Cero <+> x = x Por el principio de inducción: Caso Base: Cero <+> Cero = Cero Paso Inductivo: x :: Nat Cero <+> x = x HI Cero <+> (Suc x) = Suc x Caso base: Cero <+> Cero! por definición de (<+>) Cero Paso inductivo:! por definición de (<+>) Suc (Cero <+> x)! por hipótesis de inducción Suc x Cuando en la proposición considerada aparece más de una variable se puede realizar la inducción sobre alguna de ellas. Asociatividad de (<+>) x, y, z :: Nat (x <+> y) <+> z = x <+> (y <+> z) Realizando la inducción sobre la variable z: z :: Nat P (z) donde P(z) = x, y :: Nat (x <+> y) <+> z = x <+> (y <+> z) Por el principio de inducción basta con probar: Caso Base: P(Cero) Paso Inductivo: z :: Nat P (z) P(Suc z) Principio de inducción para el tipo Expr (49)? Cero <+> (Suc x)

16 Capítulo 4. Definiciones de tipo 55 Sobrecarga Haskell permite definir funciones monomórficas y polimórficas. Un ejemplo de función monomórfica: not :: Bool Bool not True = False not False = True (sólo tiene sentido para booleanos). Un ejemplo de función polimórfica: id :: a a id x = x Prelude> id True True :: Bool id con tipo Bool Bool Prelude> (id not) True False :: Bool id con tipo (Bool Bool) (Bool Bool) Una función polimórfica tiene sentido para distintos usos. Función sobrecargada: a medio camino entre las funciones monomórficas y las polimórficas. Tienen sentido para más de un tipo, pero con restricciones. Si el tipo del operador (+) fuera: (+) :: a a a permitiría 1 + 2, y True + False. Haskell utiliza un sistema de clases para modelar la sobrecarga. Una clase es un conjunto de tipos para los que tiene sentido un grupo de funciones. Existen distintas clases predefinidas y cada una contiene una serie de (tipos) ejemplares. La clase Num incluye los tipos Int, Integer, Double y Float. El modo de restringir el polimorfismo es vía un contexto: (+) :: Num a a a a