Tema 2: Introducción a la programación con Haskell

Índice

1. El sistema GHC
2. Iniciación a GHC
3. Aplicación de funciones
- 3.1. Aplicación de funciones en matemáticas y en Haskell
- 3.2. Prioridad de la aplicación de funciones
4. Guiones Haskell
5. Material complementario
6. Bibliografía

1. El sistema GHC

Los programa funcionales pueden evaluarse manualmente (como en el tema anterior).
Los lenguajes funcionales evalúan automáticamente los programas funcionales.
Haskell es un lenguaje funcional.
GHC (Glasgow Haskell Compiler) es el intérprete de Haskell que usaremos en el curso.

2. Iniciación a GHC

2.1. Inicio de sesión con GHCi

Inicio mediante ghci

I1M> ghci
GHCi, version 6.10.3: http://www.haskell.org/ghc/  :? for help
λ>

La llamada es λ>
Indica que ha cargado las definiciones básicas que forman el preludio y el sistema está listo para leer una expresión, evaluarla y escribir su resultado.

2.2. Cálculo aritmético

2.2.1. Operaciones aritméticas

Operaciones aritméticas en Haskell:

λ> 2+3
5
λ> 2-3
-1
λ> 2*3
6
λ> 7 `div` 2
3
λ> 2^3
8

2.2.2. Precedencia y asociatividad

Precedencia:
```
λ> 2*10^3
2000
λ> 2+3*4
14
```

Asociatividad:

λ> 2^3^4
2417851639229258349412352
λ> 2^(3^4)
2417851639229258349412352
λ> 2-3-4
-5
λ> (2-3)-4
-5

2.2.3. Seleccionar y eliminar

Seleccionar el primer elem#begin_example
```
head [1,2,3,4,5]  ==  1
```
Eliminar el primer elemento de una lista no vacía:
```
tail [1,2,3,4,5]  ==  [2,3,4,5]
```
Seleccionar el n-ésimo elemento de una lista (empezando en 0):
```
[1,2,3,4,5] !! 2  ==  3
```
Seleccionar los n primeros elementos de una lista:
```
take 3 [1,2,3,4,5]  ==  [1,2,3]
```
Eliminar los n primeros elementos de una lista:
```
drop 3 [1,2,3,4,5]  ==  [4,5]
```
Calcular la longitud de una lista:
```
length [1,2,3,4,5]  ==  5
```
Calcular la suma de una lista de números:
```
sum [1,2,3,4,5]  ==  15
```
Calcular el producto de una lista de números:
```
product [1,2,3,4,5]  ==  120
```
Concatenar dos listas:
```
[1,2,3] ++ [4,5]  ==  [1,2,3,4,5]
```
Invertir una lista:
```
reverse [1,2,3,4,5] ==  [5,4,3,2,1]
```

2.3. Cálculos con errores

Ejemplos de cálculos con errores

λ> 1 `div` 0
*** Exception: divide by zero
λ> head []
*** Exception: Prelude.head: empty list
λ> tail []
*** Exception: Prelude.tail: empty list
λ> [2,3] !! 5
*** Exception: Prelude.(!!): index too large

3. Aplicación de funciones

3.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: \(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\).
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.

3.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 \(f(a)+b\).
Ejemplos de expresiones Haskell y matemáticas:

Matemáticas Haskell

\(f(x)\) f x

\(f(x,y)\) f x y

\(f(g(x))\) f (g x)

\(f(x,g(y))\) f x (g y)

\(f(x)g(y)\) f x * g y

Matemáticas	Haskell
\(f(x)\)	`f x`
\(f(x,y)\)	`f x y`
\(f(g(x))\)	`f (g x)`
\(f(x,g(y))\)	`f x (g y)`
\(f(x)g(y)\)	`f x * g y`

4. 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

4.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:

λ> cuadruple 10
40
λ> 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:

λ> factorial (doble 2)
24
λ> doble (media [1,5,3])
6

4.2. Nombres de funciones

Los nombres de funciones tienen que empezar por una letra en minúscula. Por ejemplo, sumaCuadrado, suma_cuadrado, suma2.

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.

4.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.

4.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]

5. Material complementario

El código del tema se encuentra en este enlace.

Este tema también se encuentra en los siguientes formatos:

Como transparencias en PDF.
Como libro interactivo en IHaskell sobre Jupyter.
Como vídeos de clase: vídeo 1 y vídeo 2.

6. Bibliografía

R. Bird. Introducción a la programación funcional con Haskell. Prentice Hall, 2000.
- Cap. 1: Conceptos fundamentales.
G. Hutton. Programming in Haskell. Cambridge University Press, 2007.
- Cap. 2: First steps.
B. O'Sullivan, D. Stewart y J. Goerzen. Real World Haskell. O'Reilly, 2008.
- Cap. 1: Getting Started.
B. Pope y A. van IJzendoorn. A Tour of the Haskell Prelude (basic functions).
B.C. Ruiz, F. Gutiérrez, P. Guerrero y J.E. Gallardo. Razonando con Haskell. Thompson, 2004.
- Cap. 2: Introducción a Haskell.
S. Thompson. Haskell: The Craft of Functional Programming, Second Edition. Addison-Wesley, 1999.
- Cap. 2: Getting started with Haskell and Hugs.