*.lhs: Hacen a Haskell intensivamente comentado.
Haskell: Su fundamento es el Cálculo Lambda (Alonzo Church, 1930s).
Haskell: Bloque de trabajo son las funciones (brazo derecho).
Haskell: Los tipos son su brazo izquierdo de trabajo: Char, Int, Float, Double...
tipos curriados o compuestos vía productos cartesianos.
Haskell: Mónadas: La manera de Haskell de modelar el mundo exterior
disciplinadamente.
Haskell: Funciones de mayor orden y funciones curriadas.
Haskell: Estrategia genérica de evaluación perezosa (lazy evaluation), lo que
origina coálgebras: Las coálgebras son estructuras duales a las álgebras.
En una álgebra queremos la intersección de inclusión; en una coálgebra
queremos la unión de la inclusión. Las coálgebras permiten justificar la
introducción y utilizamiento de algo conocido como objetos computacionales
infinitos.
Ejemplos:
1) Cálculo lambda:
> (\x -> x+1) 2
> map (\x -> (4:)) [[1],[2],[3]]
> map (\x -> x*x) [1,2,3]
> let s = sin . cos in s 2
> let f = tan . cos . sin in f 10
(Haciendo eco de las palabras del Premio Turing John Backus, de que las
variables son inútiles en la programación.)
El operador punto es composición de funciones.
2) Bloques (sin variables)
> longitud = sum . unos
> unos = map (\x -> 1)
3) Tipos:
> lonCad :: String -> Int
> lonCad = length
Aquí se enfatiza que lonCad calcula la longitud de cadenas.
4) Visto como el programa Hello.hs.
> filter (\x -> x> 10) [1..100]
A las funciones que toman como argumento a otras funciones se les llama
funciones de mayor orden.
> productoInterno:: ((Float,Float),(Float,Float)) -> Float
> productoInterno ((x1,y1),(x2,y2)) = x1*x2+y1*y2
> productoInterno':: (Float,Float) -> (Float,Float) -> Float
> productoInterno' (x1,y1) (x2,y2) = x1*x2+y1*y2
> productoInterno'':: Float ->Float -> Float -> Float -> Float
> productoInterno'' x1 y1 x2 y2 = x1*x2+y1*y2
> mul2 :: (Float, Float) -> Float
> mul2 (x,y) = x*y+2
Versión curriada (Haskell Curry)
> mul2' :: Float -> Float -> Float
> mul2' x y = x*y+2
map (mul2 2) [1,2,3,4,5]
map (\x -> (mul2 (2,x))) [1,2,3,4,5]
La diferencia es que mul2 trabaja en el dominio (Float,Float) y
y mul2' trabaja en el dominio Funciones: Float -> Float
Esta es la versión (infame) de un programa para crear los
números de Fibonacci.
> fib 1 = 1
> fib 2 = 1
> fib n | n> 2 = fib (n-1) + fib (n-2)
En una próxima ocasión generaremos su versión de flujo.
Mientras, la siguiente función genera un flujo infinito de filas del triángulo de Pascal:
> pascal = p
> where
> p = [1] : [next a | a <- p]
> next x = addRows (0:x) x
> where
> addRows (a:x) (b:y) = (a + b):(addRows x y)
> addRows [a] [] = [a]
> addRows [] [] = []
Como ejemplos de ejecución tenemos:
Main> take 5 pascal
[[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]
*Main> take 15 pascal
[[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1],[1,5,10,10,5,1],[1,6,15,20,15,6,1],[1,7,21,35,35,21,7,1],[1,8,28,56,70,56,28,8,1],[1,9,36,84,126,126,84,36,9,1],[1,10,45,120,210,252,210,120,45,10,1],[1,11,55,165,330,462,462,330,165,55,11,1],[1,12,66,220,495,792,924,792,495,220,66,12,1],[1,13,78,286,715,1287,1716,1716,1287,715,286,78,13,1],[1,14,91,364,1001,2002,3003,3432,3003,2002,1001,364,91,14,1]]
*Main> pascal!!4
[1,4,6,4,1]
*Main> (pascal!!4)!!3
4
