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) lo multiplica por s i 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 --rea liza 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 luego 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 le llama n

|n==0 =1 --Es ta condicin es la condicin para que la funcin deje --de l lamarse a si misma

|n>0 = fac (n-1)*n --Mientras n sea mayor a 0, la funcin se llamar recursivamente, --envindose como parmetro el mismo que se recibe pero --disminuido 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

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 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)

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