Apunte Haskell

Vista previa del material en texto

Programación Funcional
Haskell
Que lenguaje usan sus conceptos ?
Comentarios
● Un comentario de una sola linea comienza con ‘--’
● Los comentarios de varias lineas comienzan con ‘{-’ y se extienden hasta 
‘-}’
Tipos predefinidos
● Tipos Básicos
○ Bool ----> Ejemplo: True y False
○ Char ----> Ejemplo: ‘a’, ‘B’, ’1’, ‘+’
○ String ----> Ejemplo: “abc”, “1 + 2 = 3”
○ Int ----> Ejemplo: 123, -15
○ Integer ----> Ejemplo: 123456789123456789
○ Float ----> Ejemplo: 1.2, -23.34
○ Double ----> Ejemplo: 1.2, -23.34
● Tipos Compuestos
○ Tipos listas ---> Ejemplo: [True, False], [‘a’, ‘b’, ‘c’], [“uno”, “dos”]
○ Tipos tuplas ---> Ejemplo: (‘a’,’b’), ((‘a’, ‘b’),[‘c’, ‘d’])
Prototipo de funciones
● Definición de la signatura: se especifican los tipos de los datos 
entrada y salida que posee una función.
● Implementacion del cuerpo de la función: se especifica la 
descripción de la función para transformar los datos de entrada en 
los datos de salida
nombre_funcion :: tipo_argumento -> tipo_resultado
nombre_funcion nombre_argumento = <implementación>
doble :: Int -> Int
doble X = 2 * X
Funciones por casos
● if then else
● case of
● guardas
Estructura condicional 
Sintaxis: Ejemplo:
if <expresion_logica> then 
<accion_en_caso_verdadero> 
else 
<accion_ en_caso_falso>
parGrande :: Integer -> Char
parGrande x = if even x then if x > 10 then 'A'
 else 'N'
 else 'N'
Case of
Sintaxis: Ejemplo:
case <nombre_argumento>of 
<caso1> -> <implementación1>
<caso2> -> <implementación2>
otherwise -> <implementación>
menu x y z = case z of 
 1 -> x + y 
 2 -> x - y 
 3 -> x * y 
 otherwise -> x / y
Guardas
Sintaxis: 
Ejemplo:
nombre_funcion <nombre_argumento> | <expresion> = <implementación1>
 | <expresion> = <implementación2>
| otherwise = <implementación>
mayor x y | x > y = x 
 |otherwise = y
Bucles y otros tipos de estructuras de control
Usaremos ………………. 
● Una función recursiva es aquella que en su definición se invoca a sí 
misma. La misma por lo general cuenta con una definición recursiva y 
al menos un caso base que corta la recursividad.
Propiedades:
 
RECURSIÓN
● Tiene que tener uno o más casos base
● Las llamadas recursivas del lado derecho tienen 
que acercarse al caso base, con relación a los 
parámetros del lado izquierdo de la ecuación
Ejemplo de Recursion
Ejemplo: -- sumar los elementos de un numero
sumaDigitos:: Int->Int
sumaDigitos 0 = 0
sumaDigitos x = mod x 10 + sumaDigitos(x `div` 10)
Prefija Infija
Tuplas
● Una tupla es un tipo de dato compuesto donde (x1, x2.. xn) tiene tipos t1, t2… tn
● Las tuplas permiten representar un tipo de dato compuesto, pero con 
elementos que pueden ser de distinto tipo. El número de elementos es 
fijo (siempre el mismo).
(23, 02, 1973) => tupla de 3 elementos para representar una fecha
("Juan", 23) => tupla de 2 elementos para representar una persona
Funciones que aplican sobre Tuplas
● Hay funciones estándar para separar una tupla de dos elementos: fst 
devuelve el primer elemento de la tupla, snd devuelve el segundo 
elemento.
fst (a, _) = a
snd (_, b) = b
● ¿De qué tipo son?
fst :: (a,b) -> a
snd :: (a,b) -> b
Ejemplo:
λ snd ("Pedro", True)
True
λ snd ("Maria", (30, 4))
(30,4)
Listas
● Una lista es una serie de elementos del mismo tipo.En esa serie puede no 
haber elementos, en ese caso la lista es vacía; se la simboliza con [].
● Son útiles para modelar las materias aprobadas por un alumno, las 
mascotas que tiene una persona, los empleados de una compañía, etc.
Ejemplo:
[1, 2, 3]
["Hola", "mundo"]
['H', 'o', 'l', 'a']
Ejemplo:
λ [ "hola", True]
Couldn't match expected type 
‘[Char]’ with actual type ‘Bool’
In the expression: True
In the expression: ["hola", 
True]
Algunas funciones aplicadas a listas
● head :: [a] -> a 
● tail :: [a] -> [a] 
● (:) :: a -> [a] -> [a] 
● (++) :: [a] -> [a] -> [a]
● length :: [a] -> Int 
λ head [2,3,4]
2
● reverse :: [a] -> [a]
● last :: [a] -> a
● take :: Int->[a] ->[a]
● drop:: Int->[a] -> [a]
● zip:: [a]->[b] -> [(a,b)]
λ tail [2,3,4]
[3,4]
λ 1: [2,3,4]
[1,2,3,4]
λ [2,3] ++ [5,6]
[2,3,5,6]
λ length [2,3,4]
3
λ reverse [2,3,4]
[4,3,2]
λ last [2,3,4]
4
λ take 2 [2,3,4]
[2,3]
λ drop 2 [2,3,4]
[4]
λ zip [1,2,3]['a','b']
[(1,'a'),(2,'b')]
Listas por comprensión
● expresión: La expresión es una operación que se aplicará sobre el 
cualificador.
● cualificador: puede ser un 
○ generador: Un cualificador de la forma pat<-exp es utilizado para extraer cada 
elemento que encaje con el patrón pat de la lista exp en el orden en que aparecen los 
elementos de la lista. 
○ filtro: Una expresión de valor booleano
[expresión |cualificador1 , cualificador2, … , cualificadorN]
λ [ x*x| x<-[1..10]]
[1,4,9,16,25,36,49,64,81,100]
λ [ x*x| x<-[1..10], even x]
[4,16,36,64,100]
Recursión sobre Listas
● Siendo las listas estructuras recursivas (compuestas por una cabeza y una 
cola que a su vez es una lista) la forma más natural para trabajar con ellas 
es recursivamente.
Ejemplo:
producto :: Num a => [a] -> a
producto [] = 1
producto (n:ns) = n * producto ns
Funciones de Orden Superior
 Las funciones pueden tomar funciones como 
parámetros y devolver funciones como resultado. 
Una función que hace ambas cosas o alguna de ellas se 
llama función de orden superior.
Funciones de Orden Superior ( MAP - FILTER)
 
MAP FILTER
map :: (a -> b) -> [a] -> [b]
map f [] = []
map f (x:xs) = f x : map f xs
● Toma 2 argumentos, uno de los cuales es una función
● Aplica f a cada elemento de xs
● El resultado es una lista con la aplicación en el mismo 
orden
filter :: (a -> Bool) -> [a] -> [a]
filter p [] = []
filter p (x:xs) | p x = x : filter p xs
 | otherwise = filter p xs
● Toma 2 argumentos, uno de los cuales es un predicado
● El resultado es una lista con los elementos que cumplen 
el predicado
Ejemplo:
Prelude> map succ [1,2,3,4]
[2,3,4,5]
Prelude> map not [False, False, True]
[True,True,False]
Ejemplo:
Prelude> filter (<2) [3,1,0,6,9]
[1,0]
Prelude> filter even [8,2,3,6,11]
[8,2,6]
Clases
● Una clase es una colección de tipos junto con cierta operaciones 
sobrecargadas llamadas métodos.
● Interfaz que definen comportamiento
Clase Funciones Descripción
Eq == , /= tipos comparables por igualdad
Ord >, <, >=,<= tipos ordenados
Show show tipos mostrables
Read read tipos legibles
Num +, -, * tipos numéricos
Polimorfismo
Ejemplos:
ghci> :t head
head :: [a] -> a
Las funciones que tienen variables de tipo son llamadas funciones 
polimórficas
¿Que es la a?¿Es un tipo?
Es una variable de tipo
Variables anónimas
Las variables anónimas _ (guión bajo) funcionan como una variable común en 
términos de macheo
Cláusula where
Te dejan asociar variables al final de una función de forma que toda la 
función pueda acceder a ella, incluyendo todas las guardas.
multiplicaTuplas :: [(Int,Int)] -> [Int]
multiplicaTuplas [] = []
multiplicaTuplas (x:xs) = (k * h): multiplicaTuplas xs
where k = fst x
 h = snd x
vocal :: String -> String 
vocal "" = "" 
vocal n | k=="a"||k=="e"||k=="i"||k=="o"||k=="u" = k++(vocal (tail n)) 
 | otherwise = ""++(voc (tail n)) 
 where k = take 1 n
Expresión Let
Te deja asociar variables en cualquier lugar y son expresiones en si mismas, 
pero son locales, asi que no pueden extenderse entre las guardas.
Sintaxis:
let <definición> in <expresión>
Las variables que definamos en la expresión let son accesibles en la parte in
Main > 2 + (let x = 5 in x * 2)
12
ejemplo x y = let r = 2*x 
 s = 6*y
 in r + s
Expresiones λ
Son funciones anónimas.(funciones anónimas son aquellas que no tienen 
un identificador, un nombre)
λx → x +x
En haskell: λ se escribe\ y → se escribe ->
doble = \ x -> x+ x
consola:
> (\ x -> x+ x) 2
> 4
> map (\n -> n + 1) [1 .. 10]
> [2,3,4,5,6,7,8,9,10,11]