INSTITUTO TECNOLGICO DE TEHUACN

DEPARTAMENTO DE INGENIERIA EN SISTEMAS COMPUTACIONALES

CARRERA: INGENIERIA EN SISTEMAS COMPUTACIONALES
ASIGNATURA: PROGRAMACION LOGICA Y FUNCIONAL
PERIODO: ENERO JUNIO 2015

GLOSARIO HASKELL

Alumno:
GUEVARA RIVERA JUAN CARLOS

PROFESOR: ING. NGEL ARAOZ BALTAZAR

Tehuacn Pu. 25 de Marzo de 2015

FUNCIONES

DESCRIPCION

lgebra booleana

&& representa el Y lgico mientras que ||

representa el O lgico not niega True a False
y viceversa.

ghci> True && False

False
ghci> False || True
True

la comprobacin de igualdad se realiza as

ghci> 5 == 5
True
ghci> 5 /= 4
True

succ

Ttoma cualquier cosa que tenga definido un

sucesor y devuelve ese sucesor

ghci> succ 8
9

min y max

Toman dos cosas que puedan ponerse en

orden.

ghci> min 3.4 3.2

3.2
ghci> max 100 101
101

doubleMe x = x + x

Nombre de la funcin es seguido por los

parmetros separados por espacios, cuando
estamos definiendo funciones, hay un = y
luego definimos lo que hace la funcin, toma
un nmero y lo multiplica por dos.
Palabra reservada let para definir un nombre,
Hacer let a = 1 dentro de GHCi es equivalente
Ha escribir a = 1 en un fichero y luego
cargarlo.
Concatenar dos listas, cosa que conseguimos
con el operador ++.
Obtener un elemento de la lista sabiendo su
ndice, utilizamos!!. Los ndices empiezan por
0.
Listas tambin pueden contener listas. Estas
tambin pueden contener a su vez listas que
contengan listas, que contengan listas

ghci> doubleMe 9
18

Toma una lista y devuelve su cabeza. La

cabeza de una lista es bsicamente el primer
elemento.
Toma una lista y devuelve su cola. En otras
palabras, corta la cabeza de la lista
Toma una lista y devuelve su ltimo elemento.

ghci> head [5,4,3,2,1]

5

comprobacin

let

++
!!

let

head

tail
last
init
length
null

reverse
take
drop
product
elem

rangos

EJEMPLO

Toma una lista y devuelve toda la lista

excepto su ltimo elemento.
Toma una lista y obviamente devuelve su
tamao.
Comprueba si una lista est vaca. Si lo est,
devuelve True, en caso contrario devuelve
False.
pone del revs una lista
Toma un nmero y una lista y extrae dicho
nmero de elementos de una lista
Funciona de forma similar, solo que quita un
nmero de elementos del comienzo de la lista
toma una lista de nmeros y devuelve su
producto
Toma una cosa y una lista de cosas y nos dice
si dicha cosa es un elemento de la lista.

Son

una

manera

de

crear

listas

que

ghci> let lostNumbers = [4,8,15,16,23,42]

ghci> "hello" ++ " " ++ "world"

"hello world"
ghci> "Steve Buscemi" !! 6
'B'
ghci> let b = [[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3]]
ghci> b
[[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3]]

ghci> tail [5,4,3,2,1]

[4,3,2,1]
ghci> last [5,4,3,2,1]
1
ghci> init [5,4,3,2,1]
[5,4,3,2]
ghci> length [5,4,3,2,1]
5
ghci> null [1,2,3]
False
ghci> reverse [5,4,3,2,1]
[1,2,3,4,5]
ghci> take 3 [5,4,3,2,1]
[5,4,3]
ghci> drop 3 [8,4,2,1,5,6]
[1,5,6]
ghci> product [6,2,1,2]
24
ghci> 4 `elem` [3,4,5,6]
True
ghci> 10 `elem` [3,4,5,6]
False
ghci> [1..20]

cycle

repeat

contengan una secuencia aritmtica de

elementos enumerables.
Toma una lista y crea un ciclo de listas
iguales infinito. Si intentramos mostrar el
resultado nunca terminara as que hay que
cortarlo en alguna parte.
Toma un elemento y produce una lista infinita
que contiene ese nico elemento repetido. Es
como hacer un ciclo de una lista con un solo
elemento.

replicate
listas intensionales
fst
snd
length'

:t
head

show

read

fromIntegral (length

Listas:
Toma una dupla y devuelve su primer
componente.
Toma una dupla y devuelve su segundo
componente.
_ Significa que no nos importa lo que
vayamos a extraer de la lista, simplemente
escribimos _. La funcin reemplaza cada
elemento de la lista original por 1 y luego los
suma. Esto significa que la suma resultante
ser el tamao de nuestra lista.

case

maximum

Replicate
(forma recursiva)
elem

ghci> fst ("Wow", False)

"Wow"
ghci> snd (8,11)
11
length' xs = sum [1 | _ <- xs]

Esta funcin toma dos listas y las une en una

lista uniendo sus elementos en una dupla.
TIPOS
El cual, seguido de una expresin vlida nos
dice su tipo
representa una funcin que toma una lista de
cualquier tipo y devuelve un elemento de ese
mismo tipo (el primero)
Toma un valor de un tipo que pertenezca a la
clase Show y lo representa como una cadena
de texto
Toma una cadena y devuelve un valor del tipo
que es miembro de Read.

ghci> zip [1 .. 5] ["uno","dos","tres","cuatro","cinco"]

[(1,"uno"),(2,"dos"),(3,"tres"),(4,"cuatro"),(5,"cinco")]

Suma nmeros enteros y flotantes

FUNCIONES

fromIntegral (length [1,2,3,4]) + 3.2.

Funcin trivial en el que dado un nombre y un

apellido devuelva sus iniciales

let

ghci> take 10 (repeat 5)

[5,5,5,5,5,5,5,5,5,5]

ghci> let xxs = [[1,3,5,2,3,1,2,4,5],[1,2,3,4,5,6,7,8,9],

[1,2,4,2,1,6,3,1,3,2,3,6]]

lucky

where

ghci> take 10 (cycle [1,2,3])

[1,2,3,1,2,3,1,2,3,1]

Ghci> replicate 3 10
[10,10,10].

Listas intencionales

zip

[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]

where son una construccin sintctica que te

dejan ligar variables al final de una funcin de
forma que toda la funcin pueda acceder a
ella, incluyendo todas las guardas.
let sirven para ligar variables en cualquier
lugar y son expresiones en s mismas, pero
son muy locales, as que no pueden
extenderse entre las guardas.
Tomar un valor, realizar un ajuste de patrones
sobre l, evaluar trozos de cdigo basados en
su valor
Toma una lista de cosas que pueden ser
ordenadas (es decir instancias de la clase de
tipos Ord) y devuelve la ms grande.

Que toma un elemento y una lista y busca si

ghci> :t 'a' 'a' :: Char

ghci> :t head
head :: [a] -> a
ghci> show 5.334 "5.334

ghci> read "8.2" + 3.8

12.0

lucky 7 = "El siete de la suerte!"

initials :: String -> String -> String
initials firstname lastname = [f] ++ ". " ++ [l] ++ "."
where (f:_) = firstname
(l:_) = lastname

cylinder :: (RealFloat a) => a -> a -> a

cylinder r h =
let sideArea = 2 * pi * r * h
topArea = pi * r ^2
in sideArea + 2 * topArea
head' :: [a] -> a
head' [] = error "head no funciona con listas vacas!"
head' (x:_) = x
maximum' [] = error "Mximo de una lista vaca"
Ghci > replicate 3
[5,5,5].
elem' a [] = False

quicksort
applyTwice

zipWith'

flip. flip

map

filter

dicho elemento est en esa lista.

quicksort :: (Ord a) => [a] -> [a]
El primer parmetro es una funcin que toma
algo y devuelve algo del mismo tipo. El
segundo parmetro es algo de ese mismo tipo
y tambin devuelve algo de ese tipo.
Existe un parmetro extra, la funcin de
unin, pero este parmetro no tiene
importancia en el caso base as que usamos _
con l. El cuerpo de la funcin para el ltimo
patrn es tambin muy similar al de zip, solo
que no hace (x, y) sino f x y.
Toma una funcin y devuelve una funcin que
es como nuestra funcin original, solo que
los
dos
primeros
parmetros
estn
intercambiados.
Toma una funcin y una lista y aplica esa
funcin a cada elemento de esa lista,
produciendo una nueva lista
Es una funcin que toma un predicado (un
predicado es una funcin que dice si algo es
cierto o falso, o en nuestro caso, una funcin
que devuelve un valor booleano) y una lista y
devuelve una lista con los elementos que
satisfacen el predicado.
Lambdas son funciones annimas que suelen
ser usadas cuando necesitamos una funcin
una sola vez.

ghci> quicksort [10,2,5,3,1,6,7,4,2,3,4,8,9]

[1,2,2,3,3,4,4,5,6,7,8,9,10]
ghci> applyTwice (multThree 2 2) 9
144

ghci> zipWith' (+) [4,2,5,6] [2,6,2,3]

[6,8,7,9]

ghci> flip' zip [1,2,3,4,5] "hello"

[('h',1),('e',2),('l',3),('l',4),('o',5)]

ghci> map (+3) [1,5,3,1,6]

[4,8,6,4,9]
ghci> filter (>3) [1,5,3,2,1,6,4,3,2,1]
[5,6,4]

ghci> map (\(a,b) -> a + b) [(1,2),(3,5),(6,3),(2,6),(2,5)]

[3,8,9,8,7]