INSTITUTO TECNOLGICO DE CUIDAD VICTORIA

Maestra:
Mexicano Santoyo Adriana




Primer Reporte de
prcticas en Haskell

Programacin Lgica y Funcional





Alumno:
Meza Prez Csar Antonio


Cd. Victoria Tamaulipas 22 de septiembre de 2014
INGENIERIA EN SISTEMAS COMPUTACIONALES



1

INDICE

INTRODUCCIN. .................................................................................................................... 2

1. PARADIGMAS DE PROGRAMACIN ..................................................................................... 3
Paradigma procedimental:.................................................................................................. 3
Paradigma Orientado a Objetos: ........................................................................................ 4
Paradigma modular: ........................................................................................................... 4
Paradigma Imperativo: ....................................................................................................... 4
Paradigma Lgico: .............................................................................................................. 5
Paradigma Funcional: ......................................................................................................... 5

2. DEFINICIN DE FUNCIN. .................................................................................................. 6
Funciones recursivas: ......................................................................................................... 8

3. LGICA PROPOSICIONAL. ................................................................................................... 9
Conectivos lgicos: ............................................................................................................10

4. TIPOS DE DATOS ...............................................................................................................13
Tipos de coma flotante: .....................................................................................................13
Cadenas de caracteres ( String): .........................................................................................15
Listas y su manipulacin: ...................................................................................................16
Tuplas: .............................................................................................................................17
Alcance de las variables en Haskell: ....................................................................................20

5. La Clase Enum...................................................................................................................21

CONCLUSIN........................................................................................................................23
BIBLIOGRAFA.......................................................................................................................24



2

INTRODUCCIN.

El lenguaje de programacin Haskell apareci en 1990, despus de que un comit
para la creacin de un lenguaje funcional fuera convocado. Haskell rene las
caractersticas de lenguajes funcionales de la poca. Fue diseado paralelamente en la
universidad de Yale y Glasgow.
Haskell es un lenguaje fuertemente tipificado y su orientacin es puramente funcional,
esto quiere decir que la lgica de su funcionamiento est basada en funciones adems
de que se tiene que especificar estrictamente con qu tipo de dato se va a trabajar.
Para comprender la programacin funcional son necesarios pocos conocimientos
previos, se necesita tener nocin del significado de funcin matemtica, ya que su
definicin en matemticas es similar al de la programacin funcional. Tambin es
necesario tener conocimientos bsicos de lgica proposicional.
El presente texto contiene algunas definiciones bsicas sobre Haskell y
programacin en general. Cada definicin viene seguida de un ejemplo programado en
Haskell, cada lnea de cdigo viene comentada con la explicacin de lo que en ella se
realiza.
En resumen el texto muestra las definiciones de las que se tiene que tener
conocimiento para programar en Haskell, adems de algunos ejemplos bsicos.
El texto est escrito de manera que cualquier persona, con conocimientos de
programacin o sin l, pueda entenderlo.











3

1. PARADIGMAS DE PROGRAMACIN

Para comprender de mejor forma las ventajas de Haskell sobre otros lenguajes de
programacin ms comunes, es necesario conocer las diferentes filosofas o
paradigmas de programacin.
Al estudio de los lenguajes de programacin en cuanto al enfoque del proceso de
programacin se le llama paradigma.
Un paradigma de programacin es un estilo de resolver problemas. Provee al
programador de una visin y de mtodos en la construccin de un programa.
Los diferentes lenguajes de programacin estn basados en uno o ms paradigmas.
Por ejemplo, Java est orientado al paradigma de la programacin basada en objetos,
en cambio Python soporta mltiples paradigmas de programacin.
A continuacin se describen algunos de los principales paradigmas existentes.

Paradigma procedimental:
Es el paradigma original de programacin. En este, el programador se concentra en el
procesamiento, en el algoritmo para llevar a cabo el cmputo deseado.
Fortran es el lenguaje de procedimientos original, Pascal y C le son posteriores.




Ejemplo: Pascal.
Descripcin: Programa que imprime la letra C mediante el carcter *
Program letra c;
Const {definicin de constantes}
linea1 = ***;
linea2= *;
linea3= ***;
begin {Cuerpo del programa}
write (linea1)
write (linea2)
write (linea3)
end


4

Paradigma Orientado a Objetos:
La idea principal es el encapsulamiento de datos y operaciones, en entidades llamadas
objetos. Despus durante la ejecucin del programa, los objetos pueden intercambiar
informacin entre ellos mediante envo de parmetros o variables compartidas.
Algunos ejemplos de lenguajes que usan este paradigma son; Java, C++, smalltalk,
visual Basic etc.



Paradigma modular:
Este paradigma surgi cuando se dej de dar nfasis en la organizacin de la
informacin y se enfoc ms en el diseo de procedimientos.
Este paradigma consiste en dividir el problema principal en problemas ms
pequeos.
Paradigma Imperativo:
Describe la programacin como una secuencia de instrucciones que cambian el estado
de un programa.
El cdigo mquina est basado en este paradigma
Ejemplo: Java
Descripcin: Muestra el estado de una lmpara

Public class lampara {
String estado =encendida;
Public void verEstado(){
System.out.println(La lmpara est: + estado)
}
}



5



Paradigma Lgico:
Se busca en la definicin de reglas lgicas para luego, a travs de un motor de
interferencias lgicas, responder preguntas planteadas al sistema.

Paradigma Funcional:
Concibe la computacin como la evaluacin de funciones matemticas. Hace hincapi
en la aplicacin de las funciones y composicin entre ellas, ms que en los cambios de
estados y la ejecucin secuencial de comandos.






Ejemplo: Ensamblador para microprocesador 8086
Descripcin: muestra mensaje Hola mundo
.model small
.stack
.data
Cadena1 DB Hola Mundo.$
.code
Mov ax, @data
Mov ds, ax
Mov dx, offset Cadena1
Mov ah, 9
Int 21h
Ejemplo: Haskell. square.hs
Descripcin: Funcin que calcula el cuadrado de un nmero n.
square :: Integer -> Integer
square n= n*n



6

2. DEFINICIN DE FUNCIN.

Entonces, sabemos ya que Haskell es un lenguaje basado en el paradigma funcional,
necesitamos pues, conocer que es una funcin y la manera en que nos pueden resultar
tiles.
En matemticas, las operaciones dependen de las funciones y de los parmetros que
reciben de entrada y de resultado (salida). De la misma manera en computacin, una
funcin es una buena forma de especificar un conjunto de instrucciones al CPU, siendo
ms claros a la hora de escribir algoritmos complejos.
Los lenguajes de programacin funcional, como lo dice su nombre, basan su estilo en
estas afirmaciones.
A continuacin se muestran algunos ejemplos sobre como declarar y utilizar
funciones en Haskell.



Ejemplo 01: Haskell . suma.hs
Descripcin: Funcin que calcula la suma de dos nmeros a y b.
suma :: Integer -> Integer-> Integer
suma a b= a+b

Ejemplo 02: Haskell switch.hs
Descripcin: Programa que muestra como emular switch, mediante una funcin en
haskell, se recibe un nmero y se retorna el nombre del nmero.

caso :: Integer-> String
caso 1 = "uno"
caso 2 = "dos"
caso 3 = "tres"
caso 4 = "cuatro"
caso 5 = "cinco"
caso 6 = "seis"
caso x = "Numero no valido"



7







Ejemplo 03: Haskell cubo.hs
Descripcin: Funcin que pide como parmetro un nmero y lo retorna elevado al
cubo.

cube :: Integer -> Integer --definicin de la funcin; recibe un entero y retorna un entero
cube n = n*n*n --el entero que recibe (n) l o multiplica por si mismo 3 veces


Ejemplo 04: Haskell funciones1.hs
Descripcin: Ejemplo del manejo de funciones
size :: Integer --definicion de funcin, retorna un entero
size = 12+13 --realiza la suma 12+13

square :: Integer -> Integer --definicin de funcin; recibe un entero y retorna uno.
square n= n*n --El nmero que recibe lo multiplica por si mismo

double :: Integer -> Integer --Definicin de funcin, recibe un entero y retorna otro
double n= 2*n --El entero que recibe lo multiplica por dos.

example :: Integer --Definicin de funcin; retorna un entero.
example = double (size - square (2+2)) --En esta funcin se utilizan las funciones definidas
--anteriormente

Ejemplo 05: Haskell funciones2.hs
Descripcin: Ejemplo similar al anterior.
square :: Integer -> Integer --Definicin de funcin: recibe un entero y retorna otro.
square n= n*n --El entero que recibe lo multiplica por si mismo (eleva al
cuadrado)

double :: Integer -> Integer --Definicin de funcin: recibe un entero y retorna otro
double n= 2*n --El entero recibido es multiplicado por 2

example :: Integer -> Integer --Definicin de funcin: Recibe un entero y retorna otro
example n = square (double(n))--El entero que recibe es enviado a double luego el resultado se
enva a square



8



Funciones recursivas:
En programacin, una funcin recursiva es aquella que se llama a s misma n veces
para resolver el problema.
Para utilizar una funcin recursivamente, es necesario tener una condicin de
escape, de otra forma la funcin se llamara a s misma hasta provocar errores en
tiempo de ejecucin.
En Haskell no existen los ciclos, estos son sustituidos por las funciones recursivas.
Un ejemplo clsico de recursividad es el de calcular el factorial de algn nmero.





Ejemplo 06 : Haskell. funciones3.hs
Descripcin: Ejemplo modificado del anterior.

square :: Integer -> Integer --Definicin de funcin: Recibe un entero y retorna otro
square n= n*n --El entero recibido es multiplicado por el mismo

double :: Integer -> Integer --Definicin de funcin: recibe un entero y retorna otro
double n= 2*n --El entero recibido es multiplicado por 2

example :: Integer -> Integer --Definicin de funcin: Recibe un entero y retorna otro
example n= double (square (n))--El entero que recibe es enviado a square l uego el resultado se
enva a double

Ejemplo 01: Haskell factorial.hs
Descripcin: Programa que calcula el factorial del nmero ingresado.

fac :: Integer -> Integer --Definicin de funcin: Se recibe un entero y se retorna otro
fac n --El parmetro que se recibe se l e llama n
|n==0 =1 --Esta condicin es la condicin para que la funcin deje
--de l lamarse a si misma
|n>0 = fac (n-1)*n --Mi entras n sea mayor a 0, l a funcin se llamar recursivamente,
--envi ndose como parmetro el mismo que se recibe pero
--di sminuido y se multiplicar por n



9

















Ejemplo 01: Haskell factorial2.hs
Descripcin: Programa que calcula el factorial dentro de un rango

rangoFac :: Integer -> Integer -> Integer
rangoFac m n
| m>n = 0 --sale | n<m= 0
| n==m = n --sale
| m<n = rangoFac m (n-1))*n



10

3. LGICA PROPOSICIONAL.

La lgica es la ciencia que estudia los mtodos y principios que se deben de seguir
para distinguir un razonamiento correcto de un razonamiento incorrecto.
La lgica proposicional investiga la relacin entre una serie de premisas y una
conclusin, de esta manera se sabe que una conclusin es verdadera si es
consecuencia de sus premisas.

Conectivos lgicos:
En la lgica proposicional, los conectivos lgicos son tratados como funciones de
verdad. Es decir, como funciones que toman conjuntos de valores de verdad y
devuelven valores de verdad.

Conectivo
Expresin en
lenguaje natural
Ejemplo Smbolo
Negacin NO,NOT Las tortugas NO vuelan

Conjuncin Y, AND
Los colibres vuelan Y las
serpientes se arrastran.

Disyuncin O, OR Eres gordo O eres flaco.

Implicacin si... entonces
SI pesas 90 Kilogramos
ENTONCES tienes sobrepeso.


Al observar los ejemplos anteriores, si el lector tiene conocimientos previos de
programacin habr notado cierta similitud al razonamiento que se utiliza al realizar
algoritmos computacionales. Esto es debido a que buena parte de la lgica
proposicional es utilizada en las ciencias de la computacin como medio para contar
con un razonamiento mediante sentencias de un lenguaje ms parecido al natural.
Cada una de los conectivos mostrados anteriormente dan como resultado, si se
cumplen ciertas condiciones, un resultado verdadero o falso.
Las siguientes tablas de verdad muestran el resultado de cada conectivo lgico.
Cada premisa es representada por la letra P y la letra Q, estas pueden ser verdaderas


11

o falsas. La conclusin de las premisas entonces, depende del conectivo que se le
aplica.
A continuacin se muestran las tablas de verdad de algunas de las premisas
previamente mostradas.

Negacin Conjuncin Disyuncin
p p

p Q p q

p q p q
V F

V V V

V V V
F V

V F F

V F V

F V F

F V V

F F F

F F F

En Haskell, la representacin de los conectivos lgicos bsicos viene dada por las
siguientes expresiones: || (OR), && (AND) y not (Not)
Para que la utilizacin de la lgica proposicional quede ms clara, mostraremos
algunos ejemplos de su utilizacin en el lenguaje de programacin Haskell.
Mediante el previo conocimiento del conectivo lgico de disyuncin (), el cual desde
ahora llamaremos OR, construiremos un conectivo ms complejo llamado XOR u OR
exclusivo, este devuelve verdadero nicamente si alguno de las dos preposiciones es
verdadero y la otr falsa, cualquiera de las dems configuraciones posibles da como
resultado una conclusin falsa.
La tabla de verdad que representa a XOR es la siguiente:

XOR
p Q P xor Q
V V F
V F V
F V V
F F F

El algoritmo programado en Haskell que nos da resultado equivalente a la funcin
XOR es el siguiente:


12



Not, es un conectivo definido en la librera prelude. El siguiente ejemplo muestra la
forma en que funciona.










Ejemplo 01: Haskell xor.hs
Descripcin: Funcin que se comporta como el conectivo lgico XOR
xor :: Bool -> Bool -> Bool --Definicin de funcin: recibe 2
--booleanos y retorna uno.
xor x y = ( x || y) && not ( x && y) XOR es un OR modificado, devuelve
--verdadero para las mismas combinaciones que OR, exceptuando aquellas donde
--ambas preposiciones son verdaderas

Ejemplo 02: Haskell negacin.hs
Descripcin: Funcin que se comporta como el conectivo lgico NOT
contrario :: Bool -> Bool --Definicin de la funcin, nicamente recibe un
--booleano para retornar otro
contrario x = not x --invierte el valor del parmetro booleano.
Ejemplo 03: Haskell diferentes.hs
Descripcin: Funcin que indica si 3 variable son diferentes.
--Se declara que la funcin recibir 3 enteros para devovler un booleano.
threeDifferent :: Integer -> Integer -> Integer ->Bool
--Para que todos los nmeros sean iguales se tienen que cumplir las
--condiciones siguientes
threeDifferent a b c= (a/=c)&& ( (c/=b)&& (b/=a) )


13

4. TIPOS DE DATOS

Como en cualquier lenguaje de programacin, Haskell posee diferentes tipos de datos.
A diferencia de algunos lenguajes, Haskell est estrictamente tipado, esto quiere decir
que en una funcin, es necesario declarar que tipo de dato se recibe o qu tipo de dato
se retorna, de otra manera se dan errores en tiempo de compilacin.
Tipos de coma flotante:
Son utilizados para representar fracciones. Un nmero se toma como flotante cuando
incluye un punto. Si el nmero que se quiere representar no necesita una gran
precisin, es recomendable utilizar Float, si es necesaria una buena precisin se utiliza
double .
Haskell define algunas funciones para trabajar con nmeros de coma flotante.
pi: Representa el nmero pi
log. Devuelve el logaritmo del nmero que se le enva como parmetro.
sqrt: Devuelve la raz cuadrada del nmero enviado como parmetro.
sin: Devuelve el seno del parmetro.
cos: Devuelve el Coseno del parmetro.
tan: Devuelve la Tangente del parmetro.
asin: Devuelve el arco Seno del parmetro.
acos: Devuelve el arco Coseno del parmetro.
atan: Devuelve el arco Tangente del parmetro.
A continuacin se muestran algunos ejemplos de la utilizacin de los tipos de coma
flotante:

Ejemplo 01: Haskell circunferencia.hs
Descripcin: Funcin para calcular la circunferencia de un crculo

circun :: Double -> Double --Definicin de funcin: Recibe un tipo Double y
retorna un Double.
circun d = (pi*d) --El nmero que recibe es multiplicado por la pi
(definido en haskell por --defecto).



14






Ejemplo 02: Haskell promedio1.hs
Descripcin: Calculo del promedio de tres nmeros.
promedio :: Int-> Int -> Int -> Float --Definicin de funcin: recibe 3 enteros y
retonrna un float.
promedio a b c=( (fromIntegral a)+(fromIntegral b)+(fromIntegral c))/3 --se suman los
tres argumentos, los cuales se convirtieron a Float, el resultado se divide entre 3.

Ejemplo 03: Haskell promedio2.hs
Descripcin: Calculo del promedio de tres nmeros, tambin dice cual parmetro recibido es mayor
a este promedio.

main=do --Funcin principal
putStrLn "num1: " --Imprime num:1
num1 <- getInt --Recibe de teclado y lo guarda en num1
putStrLn "num2: " --Imprime la cadena num2
num2 <- getInt --Recibe de teclado y lo guarda en num2
putStrLn "num3: " --Imprime la cadena num3
num3 <- getInt --Recibe de teclado y lo guarda en num3

let p = (promedio num1 num2 num3) --Almacena el resultado de ejecutar la
funcin --que calcula el promedio en la
variable p
--Se imprime Prom=, y se le concatena el valor de p, luego se deja un
retorno de carro para --imprimir el resultado de ejecutar la funcin
promedioM (cuya descripcin aparece abajo) pasndole cada uno de los parmetros.
putStrLn("Prom= "++show(p)++"\n"++(promedioM num1 p)++(promedioM num2
p)++(promedioM num3 p))

promedio :: Int-> Int -> Int -> Float --Definicin de funcin; recibe tres enteros para
retornar un Floa t
promedio a b c=((fromIntegral a)+(fromIntegral b)+(fromIntegral c))/3 --Calcula el promedio de
los 3 par.

promedioM :: Int-> Float-> String --Definicin de funcin; recibe tres enteros para
retornar un Float

--las funciones de abajo definen lo que se debe hacer para las condiciones, el parmetro recibido
es mayor que el --parmetro del tipo Float recibido (promedio)
promedioM num prom |fromIntegral(num)>prom =""++(show num)++"> prom "++"\n"
promedioM num prom |fromIntegral(num)<prom =""++(show num)++"< prom "++"\n"
|otherwise =""
--Esta funcin se encarga de convertir lo que se recibe de teclado en entero.
getInt :: IO Int
getInt = do
cs <- getLine
return (read cs)



15





Cadenas de caracteres ( String):
String, son secuencias de Char encerradas en comillas dobles ,en otras palabras,
un String, es una lista que contiene la representacin de un caracter (que a su vez
representa un cdigo en la tabla ASCII) en cada posicin. Al ser una lista, los tipos
String pueden utilizar cualquier funcin predefinida para las listas.
!!: Retorna el elemento en la posicin n
head: Retorna el primer elemento.
last: Retorna el tlimo elemento.
tail: Retorna todos los elementos menos el primero.
lenght: Retorna un entero que representa el largo de la lista.
reverse: Retorna la misma lista pero en orden invertido.
words: Retorna palabras separadas por espacio

Lo siguientes programas, son ejemplos de la utilizacin de cadenas de caracteres en
Haskell:
Ejemplo 04: Haskell pulagadas.hs
Descripcin: Programa que convierte centmetros a pulgadas.

pulgada = 25/64 --Se declara pulgada con su equivalente en cms, aunque no
se declara explcitamente que es --un tipo de coma
flotante, el valor 25/64 se lo da por entendido al
compilador.
cmaPulgadas :: Double-> Double --Definicin de funcin: Se pide un Double para
retornar un Double
cmaPulgadas n= (n*pulgada) --El parmetro n es multiplicado por la funcin
--pulgada.



16






Listas y su manipulacin:
Una lista es una secuencia de valores de algn tipo en especfico, representa un
conjunto del mismo tipo de datos.
Se declara de la siguiente manera:
[Int]: representa una lista de enteros, ejemplo; [5,4,2,8,6,1,0,]
[Char]: Representa una lista de caracteres, ejemplo; [H,O,L,A,]
Ejemplo 01: Haskell invertir.hs
Descripcin: Se le manda como parmetro un String, y lo devuelve invertido

main = --Funcin principal
do --para escribir varias sentencias en la misma funcin
putStrLn " Introduce una cadena de texto" --Imprime la cadena
texto <- getLine --Espera a que sea escrita una linea por
--teclado y la
--almacena en texto

--Imprime el resultado de ejecutar la funcin
--voltear mandndole como parmetro el texto recibido
putStrLn ("La cadena alreves es : "++voltear texto)

voltear :: String -> String --Definicin de funcin: Se espera un String
para retornar un String
voltear tex = reverse tex --el parmetro recibido tex se enva a la
funcin predefinida reverse

Ejemplo 02: Haskell largo.hs
Descripcin: Se le manda una cadena y retorna el largo de esta.

posicion :: String -> Int --Definicin de funcin que recibe un
String y retorna un Int
posicion cad = length cad --El parmetro recibido e enviado a la funcin
--lenght, la cual retorna un entero
--con el largo de la cadena, o lista.



17

En Haskell tambin se pueden definir listas de listas (matrices). Al declarar una
funcin a la cual se le enva como parmetro una lista, se debe definir la cola y la
cabeza de la lista



Tuplas:
Una tupla es un tipo de dato compuesto. A diferencia de las listas el nmero de
componentes es fijo y los pueden ser cada uno de un tipo distinto. Las tuplas son
creadas con parntesis, donde los elementos van dentro separados por comas.
Ejemplo:
(Tomate, 18): donde tomate representa el producto y 18 el precio.

Ejemplos del manejo de algunas Tuplas.

Ejemplo 01: Haskell ensimo.hs
Descripcin: La funcin ensimo devuelve el elemento deseado de una lista de
enteros

enesimo :: Int -> [Int] -> Int --Definicin de funcin;
recibe un entero y una lista de enteros, retorna otro entero
enesimo 1 (c:cola) = c
enesimo n (c:cola) = enesimo (n-1) cola

Ejemplo 01: Haskell tupla1.hs
Descripcin: El objetivo es sumar dos integrantes de una tupla.

addPair :: (Integer, Integer) -> Integer --Se espera una tupla con dos
--enteros para retornar un entero.
addPair (x , y )= x+y --los dos nmeros recibidos en la tupla son
--sumados y se retornan en un solo numero.


18




Mediante la utilizacin de la palabra reservada type y las Tuplas se pueden declarar
nuevos tipos de datos que se adapten a nuestras necesidades.
Un ejemplo de esto sera:

Ejemplo 02: Haskell shift.hs
Descripcin: Recibe nmeros agrupados en 2 tuplas dentro de otra, devuelve
los mismo nmeros agrupados de forma distinta.
--Se necesita como parmetro una tupla con dos nmeros enteros, la
--cual estar dentro de otra tupla que necesita otro nmero entero.
--se retorna algo parecido al parmetro de entrada, pero agrupado de
--manera distinta
shift :: ((Integer, Integer), Integer) -> (Integer,(Integer, Integer))
shift ((x, y), z) = (x,(y, z)) --cambia el orden de agrupacin.

Ejemplo 03: Haskell tupla2.hs
Descripcin: Se le ingresan dos nmeros que son devueltos ordenados de menor
a mayor dentro de una tupla.
--Se definen como parmetros dos enteros, se retorna una tupla de dos enteros.
minAndMax :: Integer -> Integer -> (Integer, Integer)

minAndMax x y --Los parmetros se nombran como x e y
|x>= y =(y,x) --Si x es mayor que y se retorna lo que se
-- indica
|otherwise =(x,y) --si no se retorna en orden contrario
Ejemplo 04: Haskell tupla3.hs
Descripcin: Muestra el nombre o el precio de algn Item que se le enva
mediante el tipo de dato ShopItem
---ShopItem
type ShopItem = (String, Int) --Se declara un nuevo tipo de dato, -
-el cual es una tupla que requiere un String y un Int

name :: ShopItem -> String --name requiere un ShopItem y retorna
--un String
price :: ShopItem -> Int --price requiere un ShopIem y retorna
--un entero

name (n, p) =n --Retorna el elemento n
price (n,p) =p --Retorna el elemento p


19



Ejemplo 05: Haskell maxOccurs.hs
Descripcin:Retorna el nmero que es mayor, junto a la cantidad de veces que
es repetido

maxOccurs ::Integer -> Integer -> (Integer, Integer)
maxOccurs a b |a>b = (a,1)
|a<b = (b,1)
|otherwise= (a,2)
Ejemplo 06: Haskell maxoccurs2.hs
Descripcin: Muestra el valor mas alto entre tres nmeros y retorna el nmero
de veces que aparece.

maxTres :: Integer -> Integer ->Integer -> (Integer, Integer)
maxTres a b c =
(x,y)
where --x llama a la funcin comparacin, la cual
--retorna el mayor de a b y c
x= comparacion [a,b,c]

--y llama a la funcin ocurrencias, la cual
-- cuenta el numero de veces que aparece x
y= ocurrencias x [a,b,c]


comparacion :: [Integer] -> Integer
comparacion [] = error "Ningn elemento"
comparacion [x] = x
comparacion (x:cola)
| x > maxTail = x
| otherwise = maxTail
where maxTail = comparacion cola

ocurrencias :: Integer -> [Integer]->Integer
ocurrencias a []=0 --La condicin de salida es que la lista sea
--vacia
ocurrencias a (c:cola) --c es la cabeza, y cola el resto
--Simplemente suma 1 cuando la cabeza es igual a la cabeza de la cola
--y 0 cuando son diferentes
|c==a = 1 + (ocurrencias a cola)
|c /=a =0 +(ocurrencias a cola)



20

Alcance de las variables en Haskell:
Las variables en Haskell se declaran mediante la utilizacin de let y where.
En Haskell las variables son definidas estrictamente como variables matemticas, esto quiere
decir que su valor nunca cambia, si no que se mantiene tal y como fue definido l a primera vez. Por
ejemplo, en Java podemos hacer esto:

If (myVar == 40){
myVar+=2;}

En Haskell lo anterior no es posible, en haskell las variables no son contenedores o
contadores.
Las variables que se usan en Haskell tienen alcance nicamente dentro de la
definicin de la funcin.







Ejemplo 01: Haskell cuadradoSuma.hs
Descripcin: Funcin que calcula el cuadrado de un parmetro, utiliza la
sentencia where.

sumSquares :: Integer -> Integer -> Integer --Definicin de
funcin, recibe dos enteros y retorna otro
sumSquares n m --Los parmetros que recibe
se nombran n y m
= sqN + sqM --El resultado ser la suma
de sqN y sqM
where --Con esta sentencia se
declaran los valores de sqN y sqM
sqN= n*n --sqN se declara como n*n
sqM= m*m --sqM se declara como m*m



21

5. La Clase Enum.

Las clases en Haskell son un conjunto de tipo para los cuales un conjunto de
operaciones definidas, tienen sentido.
La clase enum viene definida en la librera prelude. Contiene un conjunto de
operaciones para manejar secuencias aritmticas. Los tipos de datos que pueden
aceptar las operaciones contenidas en Enum, son la mayora de los tipos numricos,
adems de los Char, ya que estos ltimos son realmente un nmero que representa un
carcter segn la tabla del cdigo ASCII.
Algunas de las funciones ms importantes contenidas en enum son:
enumFrom: es equivalente a [n..]. n es el primer elemento de la lista, a partir
de donde se enumeran los elementos existentes hasta donde es posible.
-: es equivalente a la sentencia [a,n..] .
enumFromThenTo: es equivalente a la sentencia [a,n...o], donde a es el
nmero en donde comienza la enumeracin, n es el segundo nmero de la
enumeracin, o es el ltimo, los nmeros intermedios van aumentando n a
hasta llegar a o
enumFromTo: la sentencia equivalente es [an]. Donde a es el primer
elemento, despus los elementos entre a y n son enumerados, n es el ltimo
elemento que se mostrar.
Ejemplos:


Ejemplo 01: Haskell enum1.hs
Descripcin: Funcin que imprime los caracteres existentes entre a y n, en
la tabla de codificacin ASCII

enumerar :: Char -> Char -> String --recibe dos caracteres y retorna un
--String
enumerar a n= enumFromTo a n --Muestra los caracteres existentes entre
--a y n incluyndolos



22

























Ejemplo 02: Haskell enum2.hs
Descripcin: Funcin que cuenta desde a hasta n saltando nmeros.

enumerarSaltos ::Int -> Int ->Int-> [Int] --recibe 3 enteros, retorna una
--lista de enteros
--Es equivalente a decir, contar desde a hasta n de s en s saltos
enumerarSaltos a n s= enumFromThenTo a s n



23

CONCLUSIN.

El uso de la programacin funcional, como nos pudimos dar cuenta en los ejercicios
realizados, nos brinda una forma de programacin en la cual nos enfocamos ms en el
diseo del algoritmo que en los detalles tcnicos del propio lenguaje. Adems de esto,
nos da la posibilidad de ver el desarrollo del programa, como un desarrollo de frmulas
matemticas, por lo que es ms fcil programar nuestras ideas. Todo esto junto a la
utilizacin de menos lneas de cdigo.
De las caractersticas ms notables de Haskell destacan: La ausencia de ciclos, estos
son sustituidos por llamadas recursivas de las funciones.
Otra caracterstica es la imposibilidad de modificar el valor de una variable
previamente declarada dentro de una funcin, esto puede sonar algo extrao si
estamos acostumbrados a la POO, donde este rasgo es una de las caractersticas
principales, pero si comparamos la definicin matemtica de funcin vemos que es ms
acertada la definicin del paradigma funcional.
En estas prcticas, apenas se definen conceptos bsicos de Haskell, se espera que
ms adelante se aborden temas muy importantes como el manejo de hilos.















24

BIBLIOGRAFA



























Borrego, Silvia.(2009) Lgica Proposicional
Fokker, Jeroen. (1996) Programacin funcional, Universidad de Utrea
Gnosis.cx (2001) Begining with the haskell programming lenguage
Haskell 98. Index of the Haskell 98 Prelude. Recuperado de:
http://www.haskell.org/onlinereport/prelude-index.html
Labra, Jos. (1998) Introduccin al lenguaje Haskell
Rico R. Vicente. (2011) Paradigmas de programacin.
Rivadera, Gustavo. (2008) La programacin funcional: Un poderoso paradigma