Gua Rpida de Haskell

Cadenas

Esta gua rpida abarca los elementos fundamentales del lenguaje Haskell: sintaxis, palabras clave
y otros elementos. Se presenta como un archivo
ejecutable de Haskell y tambin como un documento para impresin. Cargue la fuente en su intrprete favorito para jugar con los ejemplos de
cdigo mostrados.

Sintaxis Bsica
Un comentario de una sola lnea comienza con --
y se extiende hasta el final de la lnea. Los comentarios de varias lneas comienzan con {- y se
extienden hasta -}. Los comentarios pueden ser
anidados.
Los comentarios antes de las definiciones de
funcin deben comenzar con {- | y los que estn junto a los tipos de parmetros con -- ^ para
que sean compatibles con Haddock, un sistema
para documentar cdigo en Haskell.

Palabras Reservadas
Las siguientes palabras estn reservadas para
Haskell. Es un error de sintaxis darle a una variable o a una funcin uno de estos nombres.

case
class
data
deriving
do
else
if

c 2009 Justin Bailey.

Cadenas en varias lneas

Normalmente, es
un error de sintaxis si una cadena contiene caracteres de fin de lnea. Eso es, esto es un error de
sintaxis:

string1 = "My long

string."

Comentarios

"abc" Cadena Unicode string, azcar sintctica de ['a','b','c'].

'a' Un solo caracter.

import
in
infix
infixl
infixr
instance
let

of
module
newtype
then
type
where

Se pueden emplear barras diagonales inversas

(\) para hacer escape de un fin de lnea:

Cdigos de escape
Los siguientes cdigos de
escape pueden ser utilizados en caracteres o cadenas:
\n, \r, \f, etc. Los cdigos estndar para
fin de lnea, retorno de carro, avance de
lnea, etc.
\72, \x48,
texto110 Un caracter con el valor 72 en decimal, hexadecimal y octal, respectivamente.
\& El caracter de escape null, es utilizado
para que los cdigos de escape numricos puedan aparecer junto de las literales
numricas. Es equivalente a y por lo tanto
no puede ser utilizado en literales de caracter.

Nmeros
string1 = "My long \
\string."
El rea entre las barras diagonales inversas es ignorada. Los fines de lnea en la cadena deben ser
representados explcitamente:

string2 = "My long \n\

\string."
Eso es, string1 evala como

My long string.
Mientras string2 evala como:

My long
string.
1

1 Entero o valor de punto flotante.

1.0, 1e10 Valor de punto flotante.
0o1, 0O1 Valor octal.
0x1, 0X1 Valor hexadecimal.
-1 Nmero negativo; el signo de menos
(-) no puede ir separado del nmero.

Enumeraciones
[1..10] Lista de nmeros 1, 2, . . ., 10.
[100..] Lista infinita de nmeros 100,
101, 102, . . . .
[110..100] Lista vaca; los rangos solamente avanzan hacia adelante.
[0, -1 ..] Enteros negativos.
[-110..-100] Error de sintaxis; necesita
[-110.. -100] por los negativos.
[1,3..99], [-1,3..99] Lista de 1 a 99, de
2 en 2; y de -1 a 99, de 4 en 4.

jgbailey@codeslower.com

De hecho, se puede usar cualquier valor que est

en la clase Enum:
['a' .. 'z'] Lista of caracteres a, b,
. . ., z.
[1.0, 1.5 .. 2] [1.0,1.5,2.0].
[UppercaseLetter ..] Lista de valores
GeneralCategory (en Data.Char).

Listas & Tuplas

[] Lista vaca.
[1,2,3] Lista de tres nmeros.
1 : 2 : 3 : [] Forma alterna de escribir
listas usando cons (:) y nil ([]).
"abc" Lista de tres caracteres (las cadenas
son listas).
'a' : 'b' : 'c' : [] Lista de caracteres
(lo mismo que "abc").
(1,"a") Tupla de dos elementos, un
nmero y una cadena.
(head, tail, 3, 'a') Tupla de cuatro elementos, dos funciones, un nmero y un caracter.

Regla Layout, llaves y punto y comas

Se puede escribir Haskell utilizando llaves y punto
y comas, igual que en C. Sin embargo, nadie lo
hace. En lugar de eso se emplea la regla layout,
donde se emplea espacio en blanco para separar
contextos. La regla general es: siempre usar sangras. Cuando el compilador se queje, usar ms.
Llaves y punto y comas
Los parntesis finalizan una expresin, y las llaves representan contextos. Pueden ser utilizados despus de varias
palabras clave: where, let, do y of. No pueden
c 2009 Justin Bailey.

ser utilizados al definir el cuerpo de una funcin.

Por ejemplo, esto no compila:

square2 x = { x * x; }
Sin embargo, esto funciona bien:

square2 x = result
where { result = x * x; }
Definicin de funciones
Aplique una sangra
de al menos un espacio a partir del nombre de la
funcin:

Como se puede ver arriba, la palabra clave in2

debe tambin estar en la misma columna que el
let. Finalmente, cuando se van mltiples definiciones, todos los identificadores deben aparecer en
la misma columna.

Declaraciones, Etc.
La siguiente seccin describe las reglas para la
declaracin de funciones, las listas por comprensin, y otras reas del lenguaje.

Definicin de Funciones
square x =
x * x

Las funciones se definen declarando su nombre,

los argumentos, y un signo de igual:

A menos que est presente una clusula where. En

ese caso, aplique la sangra de la clusula where al
menos un espacio a partir del nombre de la funcin y todos los cuerpos de la funcin al menos a
un espacio a partir de la palabra clave where:

square x =
x2
where x2 =
x * x
Let
Aplique sangra sobre el cuerpo del let al
menos un espacio a partir de la primera definicin
en el let. Si el let aparece por s solo en una lnea,
el cuerpo de cualquier definicin debe aparecer en
la columna despus del let:

square x =
let x2 =
x * x
in x2
2

square x = x * x
Todos los nombres de funcin deben comenzar con
letra minscula o _. Es un error de sintaxis de
cualquier otra forma.
Comparacin de patrones
Se pueden definir
varias clusulas de una funcin haciendo comparacin de patrones en los valores de los argumentos. Aqu, la funcin agree tiene cuatro casos
separados:

-- Coincide cuando se da la cadena "y".

agree1 "y" = "Great!"
-- Coincide cuando se da la cadena "n".
agree1 "n" = "Too bad."
-- Coincide cuando se da una cadena que
-- comienza con 'y'.
agree1 ('y':_) = "YAHOO!"
-- Coincide con cualquier otro valor.
agree1 _ = "SO SAD."
jgbailey@codeslower.com

Ntese que el caracter _ es un comodn y coincide con cualquier valor.

La comparacin de patrones se puede extender
a valores anidados. Asumiendo esta declaracin
de dato:

data Bar = Bil (Maybe Int) | Baz

y recordando la definicin de Maybe de la pgina 8
podemos hacer coincidir en valores Maybe anidados cuando Bil est presente:

f (Bil (Just _)) = ...

f (Bil Nothing) = ...
f Baz = ...
La comparacin de patrones tambin permite que
valores sean asociados a variables. Por ejemplo,
esta funcin determina si la cadena dada es o no
vaca. Si no, el valor asociado a str es convertido
a minsculas:

toLowerStr [] = []
toLowerStr str = map toLower str
Ntese que aqu str es similar a _ en que va a coincidir con lo que sea; la nica diferencia es que al
valor que coincide tambin se le da un nombre.
n + k Patterns
Esta (a veces controversial) comparacin de patrones hace fcil coincidir con ciertos tipos de expresiones numricas. La idea es
definir un caso base (la porcin n) con un
nmero constante para que coincida, y despus
definir las coincidencias (la porcin k) como
sumas sobre el caso base. Por ejemplo, esta es una
forma ineficiente de determinar si un nmero es o
no par:
c 2009 Justin Bailey.

isEven 0 = True
isEven 1 = False
isEven (n + 2) = isEven n
Captura de Argumentos
La captura de argumentos es til para comparar un patrn y utilizarlo, sin declarar una variable extra. Utilice un
smbolo @ entre el patrn a coincidir y la variable
a la cual asociar el valor. Este mecanismo se utiliza
en el siguiente ejemplo para asociar el primer elemento de la lista en l para mostrarlo, y al mismo
tiempo asociar la lista completa a ls para calcular
su longitud:

len ls@(l:_) = "List starts with " ++

show l ++ " and is " ++
show (length ls) ++ " items long."
len [] = "List is empty!"
Guardas
Las funciones booleanas se pueden
utilizar como guardas en definicione de funcin
al mismo tiempo que la comparacin de patrones.
Un ejemplo sin comparacin de patrones:

which n
| n == 0 = "Cero"
| even n = "Par"
| otherwise = "Impar"
Note el otherwise siempre evala verdadero y
puede ser utilizado para especificar un caso por
default.
Las guardas se pueden utilizar con patrones.
El siguiente ejemplo es una funcin que determina
si el primer caracter en una cadena es mayscula
o minscula:
3

what [] = "Cadena vaca"

what (c:_)
| isUpper c = "Mayscula"
| isLower c = "Minscula"
| otherwise = "No es letra"
Comparacin & Orden de las Guardas
La
comparacin de patrones procede en un orden de
arriba hacia abajo. De la misma forma, las expresiones con guarda son evaluadas de la primera a
la ltima. Por ejemplo, ninguna de estas funciones
sera muy interesante:

allEmpty _ = False
allEmpty [] = True
alwaysEven n
| otherwise = False
| n `div` 2 == 0 = True
Sintaxis de Registros
Normalmente la comparacin de patrones ocurre basndose en la posicin en los argumentos del valor a coincidir. Los
tipos que se declaran con sintaxis de registro, sin
embargo, pueden coincidir basndose en los nombres en el registro. Dado el siguiente tipo de datos:

data Color = C { red

, green
, blue :: Int }
podemos hacer coincidir solamente green:

isGreenZero (C { green = 0 }) = True

isGreenZero _ = False
Es posible capturar argumentos con esta sintaxis,
aunque se vuelve incmodo. Continuando con el

jgbailey@codeslower.com

ejemplo, podemos definir un tipo Pixel y una funcin que reemplace con negro valores con componente green diferente de cero:

data Pixel = P Color

-- El valor del color no se
-- modifica si green es 0
setGreen (P col@(C {green = 0})) = P col
setGreen _ = P (C 0 0 0)
Patrones Perezosos
Esta sintaxis, tambin
conocida como patrones irrefutables, permite hacer
comparacin de patrones que siempre coincida.
Esto significa que cualquier clusula utilizando el
patrn tendr xito, pero si trata de utilizar el
valor que ha coincidido puede ocurrir un error.
Esto es generalmente til cuando se debe realizar
una accin basndose en el tipo de un valor en
particular, an si el valor no est presente.
Por ejemplo, defina una clase para valores por
default:

class Def a where

defValue :: a -> a
La idea es que le d a defValue un valor del tipo
correcto y regrese un valor por default para ese
tipo. Definir instancias para tipos bsicos es fcil:

instance Def Bool where

defValue _ = False
instance Def Char where
defValue _ = ' '
Maybe es un poco ms complicado, porque queremos obtener un valor por default para el tipo,
c 2009 Justin Bailey.

pero el constructor puede ser Nothing. La siguiente definicin podra funcionar, pero no es ptima porque obtenemos Nothing cuando se le pasa
Nothing.

instance Def a => Def (Maybe a) where

defValue (Just x) = Just (defValue x)
defValue Nothing = Nothing
Preferiramos mejor obtener un valor Just (valor
por default). Aqu es donde un patrn perezoso
ayuda podemos aparentar que hemos hecho coincidir con Just x y usar eso para obtener un
valor por default, an si entra Nothing:

instance Def a => Def (Maybe a) where

defValue ~(Just x) = Just (defValue x)
Mientras el valor x no sea evaluado, estamos a
salvo. Ninguno de los tipos base necesita inspeccionar x (ver la coincidencia con _ que usan), as
que funcionar bien.
Un inconveniente con esto es que debemos
proporcionar anotaciones de tipo en el intrprete
o en el cdigo cuando usemos un constructor
Nothing. Nothing tiene tipo Maybe a pero, a
falta de informacin adicional, se debe informar
a Haskell qu es a. Algunos ejemplos de valores
por default:

-- Return "Just False"

defMB = defValue (Nothing :: Maybe Bool)
-- Return "Just ' '"
defMC = defValue (Nothing :: Maybe Char)

Listas por Comprensin

Una lista por comprensin consiste de cuatro tipos
de elementos: generadores, guardas, asociaciones locales, y objetivos. Una lista por comprensin crea
4

una lista de valores objetivo basados en los generadores y en las guardas proporcionados. Esta
comprensin genera todos los cuadrados:

squares = [x * x | x <- [1..]]

x <- [1..] genera una lista de todos los valores
enteros positivos y los coloca en x, uno por uno.
x * x crea cada elemento de la lista multiplicando
x por s mismo.
Las guardas permiten que algunos elementos
sean omitidos. El ejemplo a continuacin muestra cmo calcular los divisores (excluyendo a l
mismo) para cierto nmero. Notar cmo se usa el
mismo d en la guarda y en la expresin objetivo.
divisors n =
[d | d <- [1..(n `div` 2)]
, n `mod` d == 0]
Las asociaciones locales proveen nuevas definiciones para usar en la expresin generada o en
las guardas y generadores que las siguen. Debajo,
z es empleado para representar el mnimo de a y
b:

strange = [(a,z) |
,
,
,
,

a <-[1..3]
b <-[1..3]
c <- [1..3]
let z = min a b
z < c ]

Las comprensiones no estn limitadas a nmeros.

Funcionan con cualquier lista. Se pueden generar
todas las letras maysculas:

ups =
[c | c <- [minBound .. maxBound]
, isUpper c]
jgbailey@codeslower.com

O, para encontrar todas las apariciones de un

valor br en una lista de palabras (con ndices
desde cero):

idxs palabras br =
[i | (i, c) <- zip [0..] palabras
, c == br]
Un aspecto nico de las listas por comprensin es
que los errores en la comparacin de patrones no
causan un error; simplemente son omitidos de la
lista resultante.

Operadores
Hay muy pocos operadores predefinidos en
Haskellmuchos que parecen estar predefinidos
en realidad son sintaxis (e.g. =). En lugar de
eso, los operadores son simplemente funciones
que toman dos argumentos y tienen un soporte
sintctico especial. Cualquier as llamado operador puede ser aplicado como una funcin prefijo
usando parntesis:

3 + 4 == (+) 3 4
Para definir un nuevo operador, simplemente defnalo como una funcin normal, excepto que el
operador aparezca entre los dos argumentos. Este
es uno que inserta una coma entre dos cadenas y
asegura que no aparezcan espacios adicionales:

first ## last =
let trim s = dropWhile isSpace
(reverse (dropWhile isSpace
(reverse s)))
in trim last ++ ", " ++ trim first
c 2009 Justin Bailey.

> " Haskell " ## " Curry "

Curry, Haskell
Por supuesto, comparacin de patrones, guardas,
etc.
estn disponibles en esta forma.
La
declaracin de tipos es un poco diferentes. El operador nombre debe aparecer entre parntesis:

(##) :: String -> String -> String

Los smbolos que se permite usar para definir operadores son:

La precedencia y la asociatividad hacen que

muchas de las reglas de la aritmtica funcionen
como se espera. Por ejemplo, considere las siguientes modificaciones menores a la precedencia de
la suma y multiplicacin:

infixl 8 `plus1`
plus1 a b = a + b
infixl 7 `mult1`
mult1 a b = a * b

# \$ % & * + . / < = > ? @ \ ^ | - ~

Los resultados son sorpresivos:
Sin embargo, hay varios operadores que no
pueden ser redefinidos. Estos son <-, -> y =. En s
mismos no se les puede asignar nueva funcionalidad, pero pueden ser utilizados como parte de un
operador multicaracter. La funcin bind, >>=, es
un ejemplo.
Precedencia & Asociatividad
La precedencia
y asociatividad, colectivamente llamadas fijidad,
de cualquier operador, pueden ser establecidos
a travs de las palabras clave infix, infixr e
infixl. stas pueden ser aplicadas a funciones
en el nivel superior o a definiciones locales. La
sintaxis es:

> 2 + 3 * 5
17
> 2 `plus1` 3 `mult1` 5
25
Revertir la asociatividad tambin tiene efectos interesantes. Redefiniendo la divisin como asociativa por la derecha:

infixr 7 `div1`
div1 a b = a / b

infix | infixr | infixl precedencia op

donde precedencia vara de 0 a 9. Op puede ser
cualquier funcin que tome dos argumentos (i.e.,
cualquier operacin binaria). Que el operador
sea asociativo por la izquierda o por la derecha
est especificado por infixl o infixr, respectivamente. La declaracin infix no tiene asociatividad.
5

Obtenemos resultados interesantes:

> 20 / 2 / 2
5.0
> 20 `div1` 2 `div1` 2
20.0
jgbailey@codeslower.com

Aplicacin parcial
En Haskell las funciones no tienen que recibir todos sus argumentos de una vez. Por ejemplo, considere la funcin convertOnly, que solamente convierte ciertos elementos de una cadena dependiendo de una prueba:

convertOnly test change str =

map (\c -> if test c
then change c
else c) str
Usando convertOnly podemos escribir la funcin
l33t que convierte ciertas letras a nmeros:

l33t = convertOnly isL33t toL33t

where
isL33t 'o' = True
isL33t 'a' = True
-- etc.
isL33t _ = False
toL33t 'o' = '0'
toL33t 'a' = '4'
-- etc.
toL33t c = c
Ntese que l33t no tiene argumentos especificados. Tambin, que el argumento final de
convertOnly no es proporcionado. Sin embargo,
la declaracin de tipos de l33t cuenta la historia
completa:

l33t :: String -> String

Eso es, l33t toma una cadena y produce una cadena. Es contante en el sentido de que l33t
siempre regresa un valos que es una funcin que
c 2009 Justin Bailey.

toma una cadena y produce una cadena. l33t regresa una versin currificada de convertOnly,
donde solamente dos de sus tres argumentos han
sido provistos.
Esto puede ser llevado ms lejos. Digamos
que queremos escribir una funcin que solamente
cambie letras maysculas. Sabemos cual es la
prueba a aplicar, isUpper, pero no queremos especificar la conversin. Esa funcin puede ser escrita como:

convertUpper = convertOnly isUpper

Que tiene la declaracin de tipos:

convertUpper :: (Char -> Char)

-> String -> String
Eso es, convertUpper puede tomar dos argumentos. El primero es la funcin de conversin que
convierte caracteres individuales y el segundo es
la cadena que se va a convertir.
Se pueden crear una forma currificada de
cualquier funcin que toma mltiples argumentos. Una forma de pensar esto es que cada
flecha en la declaracin de tipos de la funcin representa una nueva funcin que puede ser
creada al proveer ms argumentos.
Secciones
Los operadores son funciones, y
pueden ser currificados como cualquier otro. Por
ejemplo, una versin currificada de + se puede
escribir como:

add10 = (+) 10
Sin embargo esto es incmodo y difcil de leer. Las
secciones son operadores currificados, usando
parntesis. Este es add10 usando secciones:
6

add10 = (10 +)
El argumento provisto puede estar del lado
izquierdo o derecho, lo que indica qu posicin
debe tomar. Esto es importante para operaciones
como la concatenacin:

onLeft str = (++ str)

onRight str = (str ++)
Que produce resultados diferentes:

> onLeft "foo" "bar"

"barfoo"
> onRight "foo" "bar"
"foobar"

Actualizando Valores y la Sintaxis de

Registros
Haskell es un lenguaje puro y, como tal, no tiene
estado mutable. Eso es, una vez que un valor ha
sido establecido nunca cambia. Actualizar es
en realidad una operacin de copiado, con valores
nuevos en los campos que cambiaron. Por ejemplo, usando el tipo Color definido antes, podemos
escribir una funcin que establece a cero el campo
green fcilmente:

noGreen1 (C r _ b) = C r 0 b
Esto es algo extenso y puede ser vuelto a escribir
con sintaxis de registro. Este tipo de actualizacin solamente establece valores para los campos especificados y copia los dems:

noGreen2 c = c { green = 0 }
jgbailey@codeslower.com

Aqu capturamos el valor Color en c y devolvemos un nuevo valor Color. Ese valor resulta tener
el mismo valor para red y blue que c y su componente green es 0. Podemos combinar esto con
comparacin de patrones para establecer los campos green y blue para que sean iguales al campo
red:

makeGrey c@(C { red = r }) =

c { green = r, blue = r }
Ntese que debemos usar captura de argumentos (c@) para obtener el valor de Color y comparar con sintaxis de registro (C { red = r})
para obtener el campo interno red.

Funciones Annimas
Una funcin annima (i.e., una expresin lambda o
simplemente lambda) es una funcin sin nombre.
Pueden ser definidas en cualquier momento de la
siguiente forma:

\c -> (c, c)
que define una funcin que toma un argumento
y regresa un tuple conteniendo ese argumento en
ambas posiciones. stas son tiles para funciones
simples donde no necesitamos un nombre. El
ejemplo siguiente determina si una cadena consiste solamente de letras maysculas o minsculas
y espacio en blanco.

mixedCase str =
all (\c -> isSpace c ||
isLower c ||
isUpper c) str
c 2009 Justin Bailey.

Por supuesto, las lambdas pueden ser regresadas

tambin de otras funciones. Este clsico regresa
una funcin que multiplicar su argumento por el
que se ha dado originalmente:

multBy n = \m -> n * m
Por ejemplo:

> let mult10 = multBy 10

> mult10 10
100

Declaracin de tipos
Haskell cuenta con inferencia de tipos, lo que significa que casi nunca es necesario declarar los
tipos. Indicarlos es todava til al menos por dos
razones.
DocumentacinAn si el compilador puede inferir los tipos de sus funciones, otros programadore o an usted mismo podra no ser capaz de hacerlo ms tarde. Declarar los tipos
en todas las funciones del nivel principal se
considera una buena prctica.
EspecializacinLas clases de tipos permiten sobrecargar funciones. Por ejemplo, una funcin que hace la negacin de una lista de
nmeros tiene la declaracin de tipos:

negateAll :: Num a => [a] -> [a]

Sin embargo, si por eficiencia o por otras
razones solamente desea permitir tipos Int,
puede hacerlo declarando los tipos:

negateAll :: [Int] -> [Int]

7

Los tipos pueden aparecer en funciones del

nivel superior y en definiciones let o where
anidadas. En general esto es til para hacer documentacin, aunque en algunos casos es requerido
para prevenir el polimorfismo. Una declaracin
de tipos es primero el nombre del item, seguido
de ::, seguido de los tipos.
Las declaraciones de tipos no necesitan
aparecer directamente sobre su implementacin.
Pueden ser especificadas en cualquier parte del
mdulo que las contiene (an debajo). Se pueden
definir al mismo tiempo varios items que tengan
la misma declaracin de tipos:

pos, neg :: Int -> Int

...
pos x | x < 0 = negate x
| otherwise = x
neg y | y > 0 = negate y
| otherwise = y
Anotaciones de Tipo
Algunas veces Haskell
no puede determinar qu tipo se debe aplicar.
La demostracin clsica de esto es el denominado
problema show . read:

canParseInt x = show (read x)

Haskell no puede compilar la funcin porque no
conoce el tipo de read x. Debemos restringir el
tipo por medio de una anotacin:

canParseInt x = show (read x :: Int)

jgbailey@codeslower.com

Las anotaciones tienen la misma sintaxis que

las declaraciones de tipo, pero pueden adornar
cualquier expresin. Ntese que la anotacin en
el ejemplo arriba est en la expresin read x, no
en la variable x. Solamente la aplicacin de funcin (e.g., read x) asocia ms fuertemente que las
anotaciones. Si ese no fuera el caso, habra sido
necesario escribir (read x) :: Int.

Igual que en la comparacin de patrones, el token

_ es un comodn que coincide con cualquier
valor.

Anidado & Captura

Se permite hacer comparacin y asociacin anidadas.

data Maybe a = Just a | Nothing

Unidad
() tipo unidad y valor unidad. El valor y
tipo que no representa informacin til.

Palabras Clave
Las palabras clave en Haskell estn listadas a continuacin, en orden alfabtico.

Case
case es similar a la declaracin switch en C# o
Java, pero puede hacer comparacin de un patrn:
la forma del valor siendo inspeccionado. Considere un tipo de datos simple.
data Choices = First String | Second |
Third | Fourth
case puede ser utilizado para determinar qu opcin se seleccion:
whichChoice ch =
case ch of
First _ -> "1st!"
Second -> "2nd!"
_ -> "Something else."
c 2009 Justin Bailey.

Figure 1: La definicin de Maybe

Usando Maybe podemos determinar si alguna
opcin fue proporcionada utilizando una comparacin anidada:

anyChoice1 ch =
case ch of
Nothing -> "No choice!"
Just (First _) -> "First!"
Just Second -> "Second!"
_ -> "Something else."
Se puede asociar un nombre al valor comparado
para poder manipularlo:

anyChoice2 ch =
case ch of
Nothing -> "No choice!"
Just score@(First "gold") ->
"First with gold!"
Just score@(First _) ->
"First with something else: "
++ show score
_ -> "Not first."
8

Orden de Comparacin
La comparacin procede de arriba hacia abajo.
Si el orden de
anyChoice se modifica de la siguiente forma, el
primer patrn siempre tendr xito:

anyChoice3 ch =
case ch of
_ -> "Something else."
Nothing -> "No choice!"
Just (First _) -> "First!"
Just Second -> "Second!"
Guardas
Las guardas, o comparaciones condicionales, se pueden utilizar en casos igual que en
la definicin de funciones. La nica diferencia es
el uso de -> en lugar de =. Esta es una funcin
que hace comparacin de cadenas sin importar si
las letras son mayscula o minscula:

strcmp s1 s2 = case (s1, s2) of

([], []) -> True
(s1:ss1, s2:ss2)
| toUpper s1 == toUpper s2 ->
strcmp ss1 ss2
| otherwise -> False
_ -> False

Clases
Una funcin en Haskell es definida para funcionar
con un cierto tipo o conjunto de tipos y no puede
ser definida ms de una vez. Muchos lenguajes cuentan con el concepto de sobrecarga,
donde una funcin puede tener diferente comportamiento dependiendo del tipo de sus argumentos. Haskell implementa sobrecarga a travs
de declaraciones de clase y de instancia. Una

jgbailey@codeslower.com

clase define una o ms funciones que pueden ser

aplicadas a cualquier tipo que sea miembro (i.e.
instancia) de esa clase. Una clase es anloga a una
interface en Java o C#, y, las intancias, a una implementacin concreta de la interface.
Una clase debe ser declarada con una o ms
variables de tipo. Tcnicamente, Haskell 98 solamente permite una variable de tipo, pero muchas
implementaciones de Haskell implementan tipos
de clase multi-parmetro, que permiten ms de una
variable de tipo.
Podemos definir una clase que provee un sabor para un tipo dado:
class Flavor a where
flavor :: a -> String
Ntese que la declaracin solamente da la
declaracin de tipos de la funcinno se proporciona la implementacin aqu (con algunas excepciones, ver Defaults en la pgina 9). Continuando, podemos definir varias instancias:

instance Flavor Bool where

flavor _ = "dulce"
instance Flavor Char where
flavor _ = "agrio"
Evaluating flavor True gives:

Defaults
Se pueden dar implementaciones por
default para las funciones en una clase. stas
son tiles cuando ciertas funciones pueden ser
definidas en trminos de otras en la clase. Un default es definido dadno un cuerpo a una de las
funciones miembro. El ejemplo cannico es Eq,
que define /= (no igual) en trminos de ==. :

class Eq a where
(==) :: a -> a -> Bool
(/=) :: a -> a -> Bool
(/=) a b = not (a == b)
Se pueden crear definiciones recursivas. Continuando con el ejemplo de Eq, == puede ser definido
entrminos de /=:

(==) a b = not (a /= b)
Sin embargo, si las instancias no proveen implementaciones suficientemente concretas de las funciones miembro, el programa que use esas instancias puede entrar en ciclo infinito.

Data
Los tipos de datos algebraicos pueden ser declarados
de la siguiente forma:

data MyType = MyValue1 | MyValue2

> flavor 'x'

"agrio"

MyType es el nombre del tipo. MyValue1 y

MyValue2 son valores del tipo y son llamados constructores. Se pueden declarar varios constructores, que se separan con el caracter |. Ntese
que los nombres de tipo y de constructor deben iniciar con letra mayscula. Es un error de sintaxis
de cualquier otra forma.

c 2009 Justin Bailey.

> flavor True

"dulce"
While flavor 'x' gives:

Constructores con Argumentos

El tipo arriba noes muy interesante excepto como una enumeracin. Se pueden declarar constructores que
tomen argumentos, permitiendo que se almacene
ms informacin:

data Point = TwoD Int Int

| ThreeD Int Int Int
Note que los argumentos para cada constructor
son nombres de tipo, no constructores. Eso significa que una declaracin como la siguiente es
ilegal:

data Poly = Triangle TwoD TwoD TwoD

En lugar de eso se debe usar el tipo Point:

data Poly = Triangle Point Point Point

Nombres de Tipos y de Constructores
Los
tipos y constructores pueden tener el mismo nombre, porque nunca sern utilizados de forma que
pudiera causar conflicto. Por ejemplo:

data User = User String | Admin String

que declara un tipo llamado User con dos constructores, User y Admin. Usando ese tipo en una
funcin hace clara la diferencia:

whatUser (User _) = "normal user."

whatUser (Admin _) = "admin user."
Cierta literatura se refiere a esta prctica como
type punning.

jgbailey@codeslower.com

Variables de Tipo
Declarar tipos de datos
polimrficos es tan fcil como agregar variables de
tipo en la declaracin:

data Slot1 a = Slot1 a | Empty1

Esto declara un tipo Slot1 con dos constructores,
Slot1 y Empty1. El constructor Slot1 puede tomar
un argumento de cualquier tipo, que es representado por la variable de tipo a arriba.
Tambin podemos mezclar variables de tipo y
tipos especficos en los constructores:

data Con = Con { conValue :: String }

| Uncon { conValue :: String }
| Noncon
whichCon con = "convalue is " ++
conValue con
Si whichCon es invocado con un valor Noncon,
ocurrir un error.
Finalmente, como se explica en otras partes,
esos nombres se pueden utilizar para comparacin de patrones, captura y actualizacin.

data Slot2 a = Slot2 a Int | Empty2

Arriba, el constructor Slot2 puede tomar un valor
de cualquier tipo y un valor Int.
Sintaxis de Registro
Se pueden declarar los
argumentos del constructor ya sea por su posicin, como se hace arriba, o utilizando sintaxis de
registros, que le da un nombre a cada argumento.
Por ejemplo, aqu declaramos un tipo Contact con
nombres para los argumentos apropiados:

data Contact = Contact { ctName :: String

, ctEmail :: String
, ctPhone :: String }
A esos nombres se les llama funciones selector
o accesor y son eso, funciones. Deben empezar
con minscula o guin bajo y no pueden tener el
mismo nombre que otra funcin en el mismo contexto. Por eso el prefijo ct en el ejemplo arriba.
Varios constructores (del mismo tipo) pueden utilizar la misma funcin accesor para valores del
mismo tipo, pero esto puede ser peligroso si el accesor no es utilizado por todos los constructores.
Considere el siguiente ejemplo:
c 2009 Justin Bailey.

Restricciones de Clase
Se pueden declarar
tipos de datos con restricciones de clase en las
variables de tipo, pero en general esta prctica es
desaprobada. Generalmente es mejor ocultar los
constructores de datos empleando el sistema de
mdulos y exportar constructores inteligentes
que apliquen las restricciones apropiadas. En
cualquier caso, la sintaxis es:

data (Num a) => SomeNumber a = Two a a

| Three a a a
Esto declara un tipo SomeNumber que tiene un argumento de variable de tipo. Los tipos vlidos son
los que estn en la clase Num.
Deriving
Muchos tipos tienen operaciones en
comn que son tediosas para definir aunque necesarias, como la habilidad de convertir de y a cadenas, comparar igualdad, u ordenar en secuencia.
Esas capacidades estn definidas como clases de
tipos en Haskell.
Como siete de estas operaciones son muy comunes, Haskell provee la palabra clave deriving
10

que automticamente implementa la clase de tipos

al tipo asociado. Las siete clases de tipos que permiten hacerlo son: Eq, Read, Show, Ord, Enum, Ix, y
Bounded.
Hay dos formas de usar deriving. La primera
se utiliza cuando un tipo solamente deriva una
clase:

data Priority = Low | Medium | High

deriving Show
El segundo es usado cuando se derivan mltiples
clases:

data Alarm = Soft | Loud | Deafening

deriving (Read, Show)
Es un error de sintaxis especificar deriving para
ninguna otra clase adems de las indicadas.

Deriving
Vea la seccin en deriving bajo la palabra clave
data en la pgina 10.

Do
La palabra clave do indica que el cdigo a continuacin estar en un contexto mondico. Las
declaraciones estn separadas por saltos de lnea,
la asignacin es indicada por <-, y se puede emplear una forma de let que no requiere la palabra
clave in.

jgbailey@codeslower.com

If con IO
if puede ser complicado cuando se
utiliza con IO. Conceptualmente no es diferente
de un if en cualquier otro contexto, pero intuitivamente es difcil de asimilar. Considere la funcin doesFileExists de System.Directory:

doesFileExist :: FilePath -> IO Bool

La declaracin if tiene esta pseudo-declaracin
de tipos:

if-then-else :: Bool -> a -> a -> a

Eso es, toma un valor Bool y evala a algn otro
valor con base en la condicin. De la declaracin
de tipos est claro que doesFileExist no puede
ser utilizado directamente por if:

wrong fileName =
if doesFileExist fileName
then ...
else ...
Eso es, doesFileExost resulta en un valor
IO Bool, mientras que if quiere un valor Bool.
El valor correcto debe ser extrado ejecutando la
accin IO:

right1 fileName = do
exists <- doesFileExist fileName
if exists
then return 1
else return 0
Note el uso de return. Como do nos coloca dentro de la mnada IO, no podemos salirexcepto
a travs de return. Ntese que no tenemos
que usar if directamente aqutambin podemos
usar let para evaluar la condicin y obtener un
resultado primero:
c 2009 Justin Bailey.

right2 fileName = do
exists <- doesFileExist fileName
let result =
if exists
then 1
else 0
return result
Una vez ms, notar donde est return. No lo
ponemos en la declaracin let. En lugar de eso
lo usamos una vez al final de la funcin.

dos Multiples
Al usar do con if o case, se requiere otro do is cualquier rama tiene mltiples
declaraciones. Un ejemplo con if:
countBytes1 f =
do
putStrLn "Enter a filename."
args <- getLine
if length args == 0
-- no 'do'.
then putStrLn "No filename given."
else
-- multiple statements require
-- a new 'do'.
do
f <- readFile args
putStrLn ("The file is " ++
show (length f)
++ " bytes long.")
Y uno con case:

countBytes2 =
do
putStrLn "Enter a filename."
args <- getLine
11

case args of
[] -> putStrLn "No args given."
file -> do
f <- readFile file
putStrLn ("The file is " ++
show (length f)
++ " bytes long.")
Una sintaxis alternativa usa llaves y punto y coma.
Todava se requiere un do, pero la sangra es innecesaria. Este cdigo muestra un ejemplo de
case, pero el principio aplica igual con if:

countBytes3 =
do
putStrLn "Enter a filename."
args <- getLine
case args of
[] -> putStrLn "No args given."
file -> do { f <- readFile file;
putStrLn ("The file is " ++
show (length f)
++ " bytes long."); }

Export
Vea la seccin module en la pgina 12.

If, Then, Else

Recuerde, if siempre devuelve un valor. Es una
expresin, no solamente una declaracin de control de flujo. Esta funcin revisa si la cadena dada
inicia con letra minscula, y, de ser as, la convierte a mayscula:
lower case letter and, if so, converts it to upper
case:

jgbailey@codeslower.com

-- Usa comparacin de patrones

-- para obtener el primer caracter
sentenceCase (s:rest) =
if isLower s
then toUpper s : rest
else s : rest
-- Cualquier otro caso es
-- sobre cadena vaca
sentenceCase _ = []

Import
Ver la seccin module en la pgina 12.

In
Ver let en la pgina 12.

Infix, infixl e infixr

Ver la seccin operators en la pgina 5.

Instance
Ver la seccin class en la pgina 8.

Let
Se pueden definir funciones localmente dentro de
una funcin usando let. La palabra clave let
debe siempre ser seguida por in. El in debe aparecer en la misma columna que la palabra clave let.
Las funciones definidas tienen acceso a todas las
dems funciones y variables dentro del mismo
contexto (incluyendo las definidas por let). En
este ejemplo, mult multiplica su argumento n por
x, que fue recibido del multiples original. mult
c 2009 Justin Bailey.

es usado por map para dar los mltiplos de x por

1 hasta 10:

onlyThree str =
let (a:b:c:[]) = str
in "The characters given are: " ++
show a ++ ", " ++ show b ++
", and " ++ show c

multiples x =
let mult n = n * x
in map mult [1..10]
Las funciones let sin argumentos son en realidad constantes y, una vez que son evaluadas, no
sern evaluadas otra vez. Esto es til para capturar porciones comunes de su funcin y reutilizarlas. El siguiente es un ejemplo que da la suma
de una lista de nmeros, su promedio, y su mediana:

listStats m =
let numbers = [1,3 .. m]
total = sum numbers
mid = head (drop (m `div` 2)
numbers)
in "total: " ++ show total ++
", mid: " ++ show mid
Deconstruccin
El lado izquierdo de una
definicin let puede tambin desestructurar su
argumento, en caso de que se requiera acceso a
sus sub-componentes. Esta definicin extraer los
primeros tres caracteres de una cadena:

firstThree str =
let (a:b:c:_) = str
in "Initial three characters are: " ++
show a ++ ", " ++
show b ++ ", and " ++
show c
Note que esto es diferente de lo que sigue, que
solamente funciona si la cadena tiene exactamente
tres caracteres:
12

Of
Vea la seccin case en la pgina 8.

Module
Un mdulo es una unidad de compilacin que exporta funciones, tipos, clases, instancias, y otros
mdulos. Un mdulo solamente se puede definir
en un solo archivo, aunque lo que exporte puede
provenir de varias fuentes. Para convertir un
archivo Haskell en mdulo basta con agregar una
declaracin de mdulo hasta arriba:

module MyModule where

Los nombres de mdulo deben comenzar con
letra mayscula pero pueden contener puntos,
nmeros y guiones bajos. Los puntos se usan para
dar un sentido de estructura, y los compiladores
Haskell los utilizarn como indicadores del directorio en el que est un archivo fuente en particular,
pero fuera de eso no tienen significado.
La comunidad Haskell ha estandarizado un
conjunto de nombres de mdulo como Data,
System, Network, etc. Asegrese de consultarlos
para seleccionar un lugar apropiado para su propio mdulo si planea liberarlo al pblico.

jgbailey@codeslower.com

Import
Las bibliotecas estndar Haskell estn
divididas en un nmero de mdulos. Se accede a
la funcionalidad provista por esas bibliotecas importndolas en el programa fuente. Para importar
todo lo que exporta una biblioteca, simplemente
use el nombre del mdulo:

import Text.Read
Todo significa todo: funciones, tipos de datos y
constructores, declaraciones de clase, y an otros
mdulos importados y luego exportados por ese
mdulo. Para importar selectivamente se pasa
una lista de nombres qu importar. Pr ejemplo,
aqu importamos algunas funciones de Text.Read:

import Text.Read (readParen, lex)

Los tipos de datos pueden ser importados de
varias formas. Podemos solamente importar el
tipo sin constructores:

import Text.Read (Lexeme)

Por supuesto, esto impide que nuestro mdulo
haga comparacin de patrones con los valores de
tipo Lexeme. Podemos importar uno o ms constructores explcitamente:

import Text.Read (Lexeme(Ident, Symbol))

Se pueden importar todos los constructores para
un tipo dado:

import Text.Read (Lexeme(..))

Podemos tambin importar
definidos en el mdulo:

tipos

import Text.Read (Read, ReadS)

c 2009 Justin Bailey.

clases

En el caso de las clases, podemos importar las funciones definidas para una clase usando una sintaxis similar a importar constructores para tipos
de datos:

import Text.Read (Read(readsPrec

, readList))
Note que, a diferencia de los tipos de datos, todas
las funciones de clase son importadas a menos que
sean explcitamente excludas. Para importar slo
las clases, usamos esta sintaxis:

import Text.Read (Read())

Exclusiones
Si la mayora, pero no todos los
nombres van a ser importados de un mdulo,
sera tedioso listarlos. Por esa razn, tambin
se pueden omitir nombres con la palabra clave
hiding (ocultar):

import Data.Char hiding (isControl

, isMark)

para mdulos que tienen un gran nmero de funciones con el mismo nombre que funciones del
Prelude. Data.Set es un buen ejemplo:

import qualified Data.Set as Set

Esta forma requiere que cualquier funcin,

tipo, constructor u otro nombre exportado por
Data.Set tenga el prefijo del alias dado (i.e., Set).
La siguiente es una forma de remover todos los duplicados de una lista:

removeDups a =
Set.toList (Set.fromList a)

Una segunda forma no crea un alias. En lugar de ello,

el prefijo se convierte en el nombre del mdulo. Podemos escribir una funcin que verifique si una cadena
est escrita en todo maysculas:

Excepto por las declaraciones de instancia,

cualquier tipo, funcin o clase pueden ser ocultos.

import qualified Char

Declaraciones de Instancia
Debe notarse que
las declaraciones de instancia (instance) no
pueden ser excludas al importar; todas las declaraciones instance en un mdulo sern importadas
cuando el mdulo sea importado.
Import Qualified
Los nombres exportados por
un mdulo (i.e., funciones, tipos, operadores, etc.)
pueden tienen un prefijo asociado a travs de importacin calificada. Esto es particularmente til
13

allUpper str =
all Char.isUpper str

Excepto por el prefijo especificado, la importacin calificada emplea la misma sintaxis que una importacin
normal. Los nombres importados se pueden limitar de
las mismas formas descritas arriba.

jgbailey@codeslower.com

Export
Si no se provee una lista de exportaciones,
entonces todas las funciones, tipos, constructores, etc.
estarn disponibles siempre que se importe el mdulo.
Note que los mdulos importados no son exportados
en este caso. Limitar los nombres exportados se consigue agregando una lista entre parntesis de los nombres antes de la palabra clave where:

module MyModule (MyType

, MyClass
, myFunc1
...)
where
La misma sintaxis que se usa para importar puede ser
usada para especificar qu funciones, tipos, constructores, y clases son exportados, con unas pocas diferencias. Si un mdulo importa otro mdulo, puede tambin
exportar ese mdulo:

module MyBigModule (module Data.Set

, module Data.Char)
where
import Data.Set
import Data.Char
Un mdulo puede tambin re-exportarse a s mismo,
lo que puede ser til cuando todas las definiciones locales y un mdulo importado dado van a se exportados.
A continuacin nos exportamos a nosotros mismos y a
Data.Set, pero no a Data.Char:

module AnotherBigModule (module Data.Set

, module AnotherBigModule)
where
import Data.Set
import Data.Char
c 2009 Justin Bailey.

Newtype
Mientras que data agrega nuevos valores y type
solamente crea sinnimos, newtype est en un
punto medio. La sintaxis para newtype est ms
restringidasolamente se puede definir un constructor, y ese constructor solamente puede tomar un argumento. Continuando con el ejemplo de arriba, podemos
definir un tipo Phone de la forma que sigue:

newtype Home = H String

newtype Work = W String
data Phone = Phone Home Work
En contraste con type, los valores H y W en
Phone no son solamente valores String. El verificador
de tipos los trata como tipos completamente nuevos.
Eso significa que nuestra funcin lowerName arriba no
compilara. Esto produce un error de tipos:

lPhone (Phone hm wk) =

Phone (lower hm) (lower wk)
En lugar de eso, debemos usar comparacin de patrones
para llegar a los valores a los que queremos aplicar
lower:

lPhone (Phone (H hm) (W wk)) =

Phone (H (lower hm)) (W (lower wk))
La observacin clave es que esta palabra clave no crea
un valor nuevo; en lugar de eso crea un tipo nuevo.
Esto proporciona dos propiedades muy tiles:
No hay costo en tiempo de ejecucin asociado al
tipo nuevo, porque en realidad no produce valores
nuevos. En otras palabras, newtype es absolutamente gratis en desempeo cuando el programa
es ejecutado.
14

El verificador de tipos puede hacer que tipos comunes como Int o String se usen de formas restringidas, especificadas por el programador.
Finalmente, se debe notar que cualquier clusula
deriving que puede ser anexada a una declaracin
data puede tambin ser usada al declarar un newtype.

Return
Ver do en la pgina 10.

Type
Esta palabra clave define un sinnimo de tipo (i.e.,
alias). Esta palabra clave no define un tipo nuevo, como
data o newtype. Es til para documentar cdigo pero,
adems de eso, no tiene efecto en el tipo de una funcin
o valor dados. Por ejemplo, un tipo de datos Person
puede ser definido como:

data Person = Person String String

donde el argumento del primer constructor representa
al nombre y el segundo al apellido. Sin embargo, el
orden y significado de los dos argumentos no es muy
claro. Una declaracin con type puede ayudar:

type FirstName = String

type LastName = String
data Person = Person FirstName LastName
Como type crea un sinnimo, la verificacin de tipos
no se afecta. La funcin lower, definida como:

lower s = map toLower s

que tiene tipo

lower :: String -> String

jgbailey@codeslower.com

puede ser usada igual en valores con tipo FirstName o

LastName:

lName (Person f l ) =
Person (lower f) (lower l)
Como type es solamente un sinnimo, no puede
declarar mltiples constructores de la forma que data
puede. Se pueden usar variables de tipo, pero no puede
haber ms que las las variables de tipo declaradas con
el tipo original. Eso significa que un sinnimo como el
siguiente es vlido:

type NotSure a = Maybe a

pero este no:

type NotSure a b = Maybe a

Ntese que se pueden usar menos variables de tipo, lo
que es til en ciertas circunstancias.

Where
De la misma forma que let, where define funciones y
constantes locales. El contexto de una definicin where

c 2009 Justin Bailey.

es la funcin actual. Si una funcin est dividida en

definiciones mltiples con comparacin de patrones, entonces el contexto de una clusula where en particular
solamente aplica a esa definicin. Por ejemplo, la funcin result a continuacin tiene un significado diferente dependiendo de los argumentos proporcionados a
la funcin strlen:

strlen [] = result
where result = "No string given!"
strlen f = result ++ " characters long!"
where result = show (length f)
Where vs. Let
Una clusula where solamente
puede ser definida al nivel de una definicin de funcin. Usualmente, eso es idntico al contexto de una
definicin let. La nica diferencia es en cundo son
utilizadas las guardas. En contraste, el contexto de una
expresin let es solamente la clusula actual de la funcin y la guarda, de existir.

Traduccin al Espaol
Jaime Soffer, jaime.soffer@gmail.com

15

Contributors
My thanks to those who contributed patches and useful suggestions: Dave Bayer, Paul Butler, Elisa Firth,
Marc Fontaine, Cale Gibbard, Stephen Hicks, Kurt
Hutchinson, Johan Kiviniemi, Adrian Neumann, Barak
Pearlmutter, Lanny Ripple, Markus Roberts, Holger
Siegel, Adam Vogt, Leif Warner, and Jeff Zaroyko.

Version
This is version 2.0. The source can be found at GitHub
(http: // github. com/ m4dc4p/ cheatsheet ). The
latest released version of the PDF can be downloaded
from
http: // cheatsheet. codeslower. com .
Visit CodeSlower.com (http: // blog. codeslower.
com/ ) for other projects and writings.
Traduccin al Espaol version 0.01 sobre la versin original mencionada arriba.
Repositorio en
http://github.com/jsoffer/cheatsheet

jgbailey@codeslower.com