Scribd
Cargar
34 vistas

Haskell Slides

Este documento introduce el lenguaje de programación Haskell. Explica que Haskell es un lenguaje funcional, puro e inmutable con evaluación tardía. Proporciona ejemplos de código Haskell simple para familiarizarse con la sintaxis, incluidos ejemplos de funciones, funciones sobre listas y recursividad. Finalmente, cubre temas más avanzados como el currying y el manejo de funciones como valores de primera clase.

Cargado por

Diego Becerra
Derechos de autor
© © All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como PDF, TXT o lee en línea desde Scribd
34 vistas

Haskell Slides

Este documento introduce el lenguaje de programación Haskell. Explica que Haskell es un lenguaje funcional, puro e inmutable con evaluación tardía. Proporciona ejemplos de código Haskell simple para familiarizarse con la sintaxis, incluidos ejemplos de funciones, funciones sobre listas y recursividad. Finalmente, cubre temas más avanzados como el currying y el manejo de funciones como valores de primera clase.

Cargado por

Diego Becerra
Derechos de autor
© © All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como PDF, TXT o lee en línea desde Scribd
Está en la página 1/ 25

Haskell for OOP(rogrammers)

Programación Avanzada - UNLaM


24 de Junio de 2019

1
2
¿Qué es Haskell?

1. Es un lenguaje de programación
2. Utiliza el paradigma funcional
2.1 Las funciones son ciudadanos de primer nivel. Es decir, se
pueden utilizar de las mismas maneras en las que se utiliza
cualquier otro tipo de valor.
2.2 El modo de trabajo de los programas realizados con Haskell se
centra alrededor de la evaluación de expresiones en lugar de la
ejecución de instrucciones.
3. Es un lenguaje puro
3.1 Es inmutable por diseño
3.2 El ser inmutable garantiza la ausencia de efectos secundarios
3.3 Tiene características de idempotencia
3.4 Beneficia el paralelismo
4. Es un lenguaje con evaluación tardía (lazy)
3
Primera prueba con Haskell

1. Abrir el navegador e ir a:
https://repl.it/languages/haskell
Plan B: https://tio.run/#haskell
2. Tipeamos el siguiente código
square(x) = x * x
main = print (square 42)
3. Presionamos Run
4. ¿Qué obtenemos?

4
Cómo funciona la evaluación tardía

square (1 + 2) -- la expresión no se evalúa


=> (1 + 2) * (1 + 2) -- aquí ya debe comenzar a evaluarse
=> 3 * (1 + 2)
=> 3 * 3
=> 9

5
Función definida en el lenguaje

-- http://bit.ly/haskell-and
(&&) :: Bool -> Bool -> Bool
True && x = x
False && x = False

Ejemplo:
('H' == 'i') && ('a' == 'm')

6
Otro enfoque: ¿qué hace el siguiente código?

int[] lst = {2, 3, 5, 7, 11};

int total = 0;
for (int i = 0; i < lst.length; i++)
total = total + 3 * lst[i]; // indexitis!

System.out.println(total);

7
Mismo ejemplo, ahora con Haskell

int[] lst = {2, 3, 5, 7, 11};

int total = 0;
for (int i = 0; i < lst.length; i++)
total = total + 3 * lst[i]; // indexitis!

System.out.println(total);

lst = [2, 3, 5, 7, 11]


total = sum (map (3*) lst)
main = print total

8
Parte 1: La fácil

Funciones propias
sumatoria :: Int -> Int
sumatoria 0 = 0
sumatoria n = n + sumatoria (n - 1)

main = print (sumatoria 10)

9
Hailstone
-- https://rosettacode.org/wiki/Hailstone_sequence#Haskell
hailstone :: Int -> Int
hailstone n
| even n = n `div` 2
| otherwise = 3 * n + 1

main = print (hailstone 3)

10
Ejercicio: Fibonacci
?

11
Ejercicio: Fibonacci (Resolución)
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)

main = print (fib 10)

12
Funciones sobre listas
-- ¿Qué hace este código?
misterio :: [Int] -> Int
misterio [] = 0
misterio (x:xs) = 1 + misterio xs

main = print (misterio [1, 2, 3, 4, 5])

13
Funciones sobre listas
-- ¿Y este otro?
misterioDos :: [Int] -> [Int]
misterioDos [] = []
misterioDos [x] = [x * x]
misterioDos (x:xs) = (x * x) : (misterioDos xs)

main = print (misterioDos [1, 2, 3, 4, 5])

14
Ejercicio: Contar los pares de una lista
contarPares :: [Int] -> Int

15
Ejercicio: Contar los pares de una lista (resolución)
contar :: Int -> Int
contar x = case (x `mod` 2) of
0 -> 1
_ -> 0

contarPares :: [Int] -> Int


contarPares [] = 0
contarPares (x:xs) = (contar x) + contarPares xs

main = print (contarPares [1, 2, 3, 4, 5, 6])

Quiz: ¿Cómo hacemos para sumarlos?

16
Ejercicio: Sumar los pares de una lista (resolución)
sumar :: Int -> Int
sumar x = case (x `mod` 2) of
0 -> x
_ -> 0

contarPares :: [Int] -> Int


contarPares [] = 0
contarPares (x:xs) = (sumar x) + contarPares xs

main = print (contarPares [1, 2, 3, 4, 5, 6])

17
Bonus: Contar “notables”
notable :: Int -> Int
notable x = case (x `mod` 2) of
0 -> 1
_ -> 0

contarNotables :: (Int -> Int) -> [Int] -> Int


contarNotables f [] = 0
contarNotables f (x:xs) = (f x) + contarNotables f xs

main = print (contarNotables (notable) [1, 2, 3, 4, 5, 6])

18
Parte 2: La moderada

Pattern Matching

quitaTres :: [a] -> [a]


quitaTres (_:_:_:xs) = xs
quitaTres _ = []

19
Dos operadores notables
• El operador ++ sirve para concatenar dos listas
• El operador :, en cambio, sirve para agregar elementos antes
de las listas

x:xs -- válido
x++xs -- no válido

xs:ys -- no válido
xs++ys -- válido

20
Ejercicios:

1. Hacer funciones para manejo de Cola (queue / dequeue)


2. Hacer funciones para manejo de Pila (push / pop)

21
Resoluciones
queue :: a -> [a] -> [a]
queue x xs = xs++[x]

dequeue :: [a] -> a


dequeue (x:xs) = x

push :: a -> [a] -> [a]


push x xs = x:xs

pop :: [a] -> a


pop (x:xs) = x

22
Parte 3: La difícil

Currying
function x y = x + y
fun y = function 3 y
fun 2

23
Otro ejemplo
applyTwice :: (a -> a) -> a -> a
applyTwice f x = f (f x)

main = print (applyTwice (*3) 2)


-- ¿Cuál es el resultado?

24
FIN

25

También podría gustarte