1 Conceptos básicos sobre tipos
¿Qué es un tipo?
Un tipo es una colección de valores relacionados.
Un ejemplo de tipos es el de los valores booleanos: Bool
El tipo Bool tiene dos valores True (verdadero) y False (falso).
v :: T representa que v es un valor del tipo T y se dice que v tiene
tipo T''.
Cálculo de tipo con :type
ghci> :type True
True :: Bool
ghci> :type False
False :: Bool
El tipo Bool -> Bool está formado por todas las funciones cuyo
argumento y valor son booleanos.
Ejemplo de tipo Bool -> Bool
ghci> :type not
not :: Bool -> Bool
Inferencia de tipos
Regla de inferencia de tipos:
f :: A -> B, e :: A
-------------------
f e :: B
Tipos de expresiones:
ghci> :type not True
not True :: Bool
ghci> :type not False
not False :: Bool
ghci> :type not (not False)
not (not False) :: Bool
Error de tipo:
ghci> :type not 3
Error: No instance for (Num Bool)
ghci> :type 1 + False
Error: No instance for (Num Bool)
Ventajas de los tipos
Los lenguajes en los que la inferencia de tipo precede a la
evaluación se denominan de tipos seguros.
Haskell es un lenguaje de tipos seguros.
En los lenguajes de tipos seguros no ocurren errores de tipos
durante la evaluación.
La inferencia de tipos no elimina todos los errores durante la
evaluación. Por ejemplo,
ghci> :type 1 `div` 0
1 `div` 0 :: (Integral t) => t
ghci> 1 `div` 0
*** Exception: divide by zero
2 Tipos básicos
Bool (Valores lógicos):
Sus valores son True y False.
Char (Caracteres):
Ejemplos: 'a', 'B', '3', '+'
String (Cadena de caracteres):
Ejemplos: "abc", "1 + 2 = 3"
Int (Enteros de precisión fija):
Enteros entre y .
Ejemplos: 123, -12
Integer (Enteros de precisión arbitraria):
Ejemplos: 1267650600228229401496703205376.
Float (Reales de precisión arbitraria):
Ejemplos: 1.2, -23.45, 45e-7
Double (Reales de precisión doble):
Ejemplos: 1.2, -23.45, 45e-7
3 Tipos compuestos
3.1 Tipos listas
Una lista es una sucesión de elementos del mismo tipo.
[T] es el tipo de las listas de elementos de tipo T.
Ejemplos de listas:
[False, True] :: [Bool]
['a','b','d'] :: [Char]
["uno","tres"] :: [String]
Longitudes:
La longitud de una lista es el número de elementos.
La lista de longitud 0, [], es la lista vacía.
Las listas de longitud 1 se llaman listas unitarias.
El tipo de una lista no informa sobre su longitud:
['a','b'] :: [Char]
['a','b','c'] :: [Char]
El tipo de los elementos de una lista puede ser cualquiera:
[['a','b'],['c']] :: [[Char]]
3.2 Tipos tuplas
Una tupla es una sucesión de elementos.
(T1, T2, ..., Tn) es el tipo de las n-tuplas cuya componente i-
ésima es de tipo Ti.
Ejemplos de tuplas:
(False,True) :: (Bool,Bool)
(False,'a',True) :: (Bool,Char,Bool)
Aridades:
La aridad de una tupla es el número de componentes.
La tupla de aridad 0, (), es la tupla vacía.
No están permitidas las tuplas de longitud 1.
El tipo de una tupla informa sobre su longitud:
('a','b') :: (Char,Char)
('a','b','c') :: (Char,Char,Char)
El tipo de los elementos de una tupla puede ser cualquiera:
(('a','b'),['c','d']) :: ((Char,Char),[Char])
3.3 Tipos de funciones
Tipos de funciones
Una función es una aplicación de valores de un tipo en valores de
otro tipo.
T1 -> T1 es el tipo de las funciones que aplica valores del tipo T1 en
valores del tipo T2.
Ejemplos de funciones:
not :: Bool -> Bool
isDigit :: Char -> Bool
Funciones con múltiples argumentos o valores
Ejemplo de función con múltiples argumentos: suma (x,y) es la
suma de x e y. Por ejemplo, suma (2,3) es 5.
suma :: (Int,Int) -> Int
suma (x,y) = x+y
Ejemplo de función con múltiples valores: deCeroA n es la lista de
los números desde 0 hasta n. Por ejemplo, deCeroA
5 es [0,1,2,3,4,5].
deCeroA :: Int -> [Int]
deCeroA n = [0..n]
Notas:
En las definiciones se ha escrito la signatura de las
funciones.
No es obligatorio escribir la signatura de las funciones.
Es conveniente escribir las signatura.
4 Parcialización
Parcialización
Mecanismo de parcialización ( en inglés): Las funciones de más de
un argumento pueden interpretarse como funciones que toman un
argumento y devuelven otra función con un argumento menos.
Ejemplo de parcialización:
suma' :: Int -> (Int -> Int)
suma' x y = x+y
suma'toma un entero x y devuelve la función suma' x que toma un
entero y y devuelve la suma de x e y. Por ejemplo,
ghci> :type suma' 2
suma' 2 :: Int -> Int
ghci> :type suma' 2 3
suma' 2 3 :: Int
Ejemplo de parcialización con tres argumentos:
mult :: Int -> (Int -> (Int -> Int))
mult x y z = x*y*z
multtoma un entero x y devuelve la función mult x que toma un
entero y y devuelve la función mult x y que toma un entero z y
devuelve x*y*z. Por ejemplo,
ghci> :type mult 2
mult 2 :: Int -> (Int -> Int)
ghci> :type mult 2 3
mult 2 3 :: Int -> Int
ghci> :type mult 2 3 7
mult 2 3 7 :: Int
Aplicación parcial
Las funciones que toman sus argumentos de uno en uno se
llaman currificadas ("curried" en inglés).
Las funciones suma' y mult son currificadas.
Las funciones currificadas pueden aplicarse parcialmente. Por
ejemplo,
ghci> (suma' 2) 3
5
Pueden definirse funciones usando aplicaciones parciales. Por
ejemplo,
suc :: Int -> Int
suc = suma' 1
suc x es el sucesor de x. Por ejemplo, suc 2 es 3.
Convenios para reducir paréntesis
Convenio 1: Las flechas en los tipos se asocia por la derecha. Por
ejemplo, Int -> Int -> Int -> Int representa a Int -> (Int -> (Int
-> Int))
Convenio 2: Las aplicaciones de funciones se asocia por la
izquierda. Por ejemplo, mult x y z representa a ((mult x) y) z
Nota: Todas las funciones con múltiples argumentos se definen en
forma currificada, salvo que explícitamente se diga que los
argumentos tienen que ser tuplas.
5 Aplicación de funciones
5.1 Aplicación de funciones en matemáticas y en
Haskell
Notación para funciones en matemáticas:
En matemáticas, la aplicación de funciones se representa
usando paréntesis y la multiplicación usando yuxtaposición o
espacios
Ejemplo: representa la suma del valor de
aplicado a y más el producto de por .
Notación para funciones en Haskell:
En Haskell, la aplicación de funciones se representa usando
espacios y la multiplicación usando *
Ejemplo: f a b + c*d representa la suma del valor
de f aplicado a a y b más el producto de c por d.
5.2 Prioridad de la aplicación de funciones
En Haskell, la aplicación de funciones tiene mayor prioridad que los
restantes operadores. Por ejemplo, la expresión Haskell f a +
b representa la expresión matemática .
Ejemplos de expresiones Haskell y matemáticas:
Matemáticas Haskell
f x
f x y
f (g x)
f x (g y)
f x * g y
6 Guiones Haskell
En Haskell los usuarios pueden definir funciones.
Las nuevas definiciones se definen en guiones, que son ficheros de
textos compuestos por una sucesión de definiciones.
Se acostumbra a identificar los guiones de Haskell mediante el
sufijo .hs
6.1 El primer guión Haskell
Iniciar emacs y abrir dos ventanas: C-x 2
En la primera ventana ejecutar Haskell: M-x run-haskell
Cambiar a la otra ventana: C-x o
Iniciar el guión: C-x C-f ejemplo.hs
Escribir en el guión las siguientes definiciones
doble x = x+x
cuadruple x = doble (doble x)
Grabar el guión: C-x C-s
Cargar el guión en Haskell: C-c C-l
Evaluar ejemplos:
ghci> cuadruple 10
40
ghci> take (doble 2) [1,2,3,4,5,6]
[1,2,3,4]
Volver al guión: C-x o
Añadir al guión las siguientes definiciones:
factorial n = product [1..n]
media ns = sum ns `div` length ns
Grabar el guión: C-x s
Cargar el guión en Haskell: C-c C-l
Evaluar ejemplos:
ghci> factorial (doble 2)
24
ghci> doble (media [1,5,3])
6
6.2 Nombres de funciones
Nombres de funciones
Los nombres de funciones tienen que empezar por una letra en
minúscula. Por ejemplo:
sumaCuadrado, suma_cuadrado, `suma
Las palabras reservadas de Haskell no pueden usarse en los
nombres de funciones. Algunas palabras reservadas son
case class data default deriving do else
if import in infix infixl infixr instance
let module newtype of then type where
Se acostumbra escribir los argumentos que son listas
usando s como sufijo de su nombre. Por ejemplo,
ns representa una lista de números,
xs representa una lista de elementos,
css representa una lista de listas de caracteres.
6.3 La regla de la indentación
En Haskell la disposición del texto del programa (la indentación)
delimita las definiciones mediante la siguiente regla:
Una definición acaba con el primer trozo de código con un
margen izquierdo menor o igual que el del comienzo de la
definición actual.
Ejemplo:
a = b + c
where
b = 1
c = 2
d = a * 2
Consejos:
Comenzar las definiciones de las funciones en la primera
columna.
Usar el tabulador en emacs para determinar el sangrado en
las definiciones.
6.4 Comentarios en Haskell
En los guiones Haskell pueden incluirse comentarios.
Un comentario simple comienza con -- y se extiende hasta el
final de la línea.
Ejemplo de comentario simple:
-- (factorial2 n) es el factorial del número n.
factorial2 n = product [1..n]
Un comentario anidado comienza con {- y termina en -}
Ejemplo de comentario anidado:
{- (factorial3 n) es el factorial del número n.
Por ejemplo, factorial 3 == 6 -}
factorial3 n = product [1..n]
