INSTITUTO TECNOLÓGICO DE CUIDAD VICTORIA INGENIERIA EN SISTEMAS COMPUTACIONALES
Primer Reporte de prácticas en Haskell Programación Lógica y Funcional
Alumno: Meza Pérez César Antonio
Maestra: Mexicano Santoyo Adriana
Cd. Victoria Tamaulipas
22 de septiembre de 2014
INDICE INTRODU INTRODUCCIÓ CCIÓN. N. ...................................................................... .............................................. 2
1. PARADIGM PARADIGMAS DE PROGRAMAC PROGRAMACIÓ IÓN N .................... ............................................ ..................... 3 Paradigm Paradigmaa procedim procedimenta ental:................................................................ l:................................................................ .................................. 3 Paradigm Paradigmaa Orientad Orientado a Objetos: ................................................................ ........................ 4 Paradigm Paradigmaa modular: modular:...................................... ................................................. .................... 4 Paradigm Paradigmaa Imperati Imperativo: vo: ............................................ ............................................... ............ 4 Paradigm Paradigmaa Lógico: Lógico:........................................... ............................................... .................... 5 Paradigm Paradigmaa Funciona Funcional: l: .................................... ................................................ ..................... 5
2. DEFINICIÓ DEFINICIÓN N DE FUNCIÓ FUNCIÓN. N. ............................................... ............................................... .... 6 Funcion Funciones es recurs recursivas: ivas: ................. ............................................... ......................................... 8
3. LÓGICA PROPOSICION PROPOSICIONAL. AL. ............................. ........................................ .............................. 9 Conectivos Conectivos lógicos lógicos::....................... ......................................... ............................................ 10
4. TIPOS DE DATOS .......................................................................... .....................................13 Tipos de coma flotante: flotante: ........................................................................ .............................13 Cadenas Cadenas de caract caracter eres es ( String String): ): ........................... ...................................... ........................15 Listas y su manipu manipulac lación: ión: ....................................... ................................................. ...........16 Tuplas: Tuplas: ............................................................... ........................................ ......................17 Alcance Alcance de las l as variables variables en Hask Haskell: ell: ............................................................................. .......20
5. La Clase Enum......................................... Enum......................................... ................................................ ..........................21
CONCLUS CONCLUSIÓ IÓN............................................................................. N............................................................................. ........................................... 23 BIBLIOG BIBLIOGRAF RAFÍA................................................................... ÍA................................................................... ............................................... .....24
1
INTRODUCCIÓN. El lenguaje de programación Haskell apareció en 1990, después de que un comité para la creación de un lenguaje funcional fuera convocado. Haskell reúne las características de lenguajes funcionales de la época. Fue diseñado paralelamente en la universidad de Yale y Glasgow. Haskell es un lenguaje fuertemente tipificado y su orientación es puramente funcional, esto quiere decir que la lógica de su funcionamiento está basada en funciones además de que se tiene que especificar estrictamente con qué tipo de dato se va a trabajar. Para comprender la programación funcional son necesarios pocos conocimientos previos, se necesita tener noción del significado de función matemática, ya que su definición en matemáticas es similar al de la programación funcional. También es necesario tener conocimientos básicos de lógica propo sicional. El presente texto contiene algunas definiciones básicas sobre H askell y programación en general. Cada definición viene seguida de un ejemplo programado en Haskell, cada línea de código viene comentada con la explicación 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, además de algunos ejemplos básicos. El texto está escrito de manera que cualquier persona, con conocimientos de programación o sin él, pueda entenderlo.
2
1. PARADIGMAS DE PROGRAMACIÓN Para comprender de mejor forma las ventajas de Haskell sobre otros lenguajes de programación más comunes, es necesario conocer las diferentes filosofías o “paradigmas” de programación.
Al estudio de los lenguajes de programación en cuanto al enfoque del proceso de programación se le llama paradigma. Un paradigma de programación es un estilo de resolver problemas. Provee al programador de una visión y de métodos en la construcción de un programa. Los diferentes lenguajes de programación están basados en uno o más paradigmas. Por ejemplo, Java está orientado al paradigma de la programación basada en objetos, en cambio Python soporta múltiples paradigmas de programación. A continuación se describen algunos de los principales paradigmas existent es.
Es el paradigma original de programación. En este, el programador se concentra en el procesamiento, en el algoritmo para llevar a cabo el c ómputo deseado. Fortran es el lenguaje de procedimientos original, Pascal y C le son posteriores.
Pascal. Programa que imprime la letra ‚ C‛ mediante el carácter ‚*‛ Program letra c; Const {definición d e constantes} linea1 = ‘ ***‘;
linea2= ‘*’; linea3= ‘***’; begin {Cuerpo del programa} write (linea1) write (linea2) write (linea3) end
3
La idea principal es el encapsulamiento de datos y operaciones, en entidades llamadas objetos. Después durante la ejecución del programa, los objetos pueden intercambiar información entre ellos mediante envío de parámetros o variables compartidas. Algunos ejemplos de lenguajes que usan este paradigma son; Java, C++, smalltalk, visual Basic etc.
Java Muestra el estado de una ‚lámpara‛ Public class lampara { String estado =‛encendida‛; Public void verEstado(){
System.ou t.println(‚La lámpara está:
‛+ estado)
} }
Este paradigma surgió cuando se dejó de dar énfasis en la organización de la información y se enfocó más en el diseño de procedimientos. Este paradigma consiste en dividir el problema principal en problemas más pequeños.
Describe la programación como una secuencia de instrucciones que cambian el estado de un programa. El código máquina está basado en este paradigma
4
Ens amblador para microprocesador 8086
muestra mensaje ‚H ola 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
Se busca en la definición de reglas lógicas para luego, a través de un motor de interferencias lógicas, responder preguntas planteadas al sistema.
Concibe la computación como la evaluación de funciones matemáticas. Hace hincapié en la aplicación de las funciones y composición entre ellas, más que en los cambios de estados y la ejecución secuencial de comandos.
Haskell. square.hs
Función que calcula el cuadrado de un número ‚n‛. square :: Integer -> Integer square n= n*n
5
2. DEFINICIÓN DE FUNCIÓN. Entonces, sabemos ya que Haskell es un lenguaje basado en el paradigma funcional, necesitamos pues, conocer que es una función y la manera en que nos pueden resultar útiles. En matemáticas, las operaciones dependen de las funciones y de los parámetros que reciben de entrada y de resultado (salida). De la misma manera en computación, una función es una buena forma de especificar un conjunto de instrucciones al CPU, siendo más claros a la hora de escribir algoritmos complejos. Los lenguajes de programación funcional, como lo dice su nombre, basan su estilo en estas afirmaciones. A continuación se muestran algunos ejemplos sobre como declarar y utilizar funciones en Haskell. Ejemplo 01: Haskell . suma.hs Descripción: Función que calcula la suma de dos números a y b.
suma :: Integer -> Integer-> Integer suma a b= a+b
Ejemplo 02: Haskell switch.hs Descripción: Programa que muestra como emular switch, medi ante una función en
haskell, se recibe un número y se retorna el nombre del número. 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"
6
Ejemplo 03: Haskell cubo.hs Descripción: Función que pide como parámetro un número y lo retorna elevado al
cubo. cube :: Integer -> Integer cube n = n*n*n
--de finición de la función; recibe un entero y retorn a un entero -- el entero que recibe (“n”) lo multiplica por si mismo 3 vece s
Ejemplo 04: Haskell funciones1.hs Descripción: Ejemplo del manejo de funciones
size :: Integer size = 12+13
--de finicion de función, retorna un e ntero --re al iza la suma 12+13
square :: Integer -> Integer square n= n*n
--de finición de función; recibe un entero y reto rna uno. --El núm ero que re cibe lo multiplica por si mismo
double :: Integer -> Integer double n= 2*n
--De finición de función, recibe un entero y retorna o tro --El en tero que re cibe lo m ultiplica por dos.
example :: Integer example = double (size - square (2+2))
--De finición de función; retorna un entero. --En e s ta función s e utilizan las funciones definidas --anteriormente
Ejemplo 05: Haskell funciones2.hs Descripción: Ejemplo similar al anterior.
square :: Integer -> Integer square n= n*n
--De finición de función: recibe un en tero y retorna otro. --El en tero que re cibe lo m ultiplica por si mismo (eleva al
cuadrado)
double :: Integer -> Integer double n= 2*n
--De finición de función: recibe un en tero y reto rna otro -- El en tero recibido es m ultiplicado por 2
example :: Integer -> Integer -- De finición de función: Recibe un entero y retorna o tro example n = square (double(n))-- El en tero que recibe es en viado a “double” luego el resultado se envía a “square”
7
Ejemplo 06 : Haskell. funciones3.hs Descripción: Ejemplo modificado del anterior.
square :: Integer -> Integer square n= n*n
--De finición de función: Re cibe u n entero y retorna o tro --El e ntero recibido es multiplicado por el mismo
double :: Integer -> Integer double n= 2*n
--De finición de función: recibe un en tero y retorna otro - -El en tero recibido es multiplicado por 2
example :: Integer -> Integer -- De finición de fu nción: Recibe un entero y reto rna o tro example n= double (square (n))-- El e ntero que recibe es enviado a “square” l uego el resultado se envía a “double”
En programación, una función recursiva es aquella que se llama a sí misma n veces para resolver el problema. Para utilizar una función recursivamente, es necesario tener una condición de “escape”, de otra forma la función se llamaría a sí misma hasta provocar errores en
tiempo de ejecución. En Haskell no existen los ciclos, estos son sustituidos por las funciones recursivas. Un ejemplo clásico de recursividad es el de calcular el factorial de algún número.
Ejemplo 01: Haskell factorial.hs Descripción: Programa que calcula el factorial del número ingresado.
fac :: Integer -> Integer fac n |n==0 =1 |n>0 = fac (n-1)*n
-- De finición de fu nción: Se recibe un entero y se retorna otro -- El p arámetro que se re cibe se l e llama “n” --Es ta co ndición es la condición para que la función deje --de llamarse a si misma --Mi en tras n s ea ma yor a 0, l a función se llamará recursivamente, --e nvi ándose como parámetro el mis mo que se re cibe pero --di sminuido y se m ultiplicará por n
8
Ejemplo 01: Haskell factorial2.hs Descripción: Programa que calcula el factorial dentro de un rango
rangoFac :: Integer -> Integer -> Integer rangoFac m n | m>n = 0 --sale | n
9
3. LÓGICA PROPOSICIONAL. La lógica es la ciencia que estudia los métodos y principios que se deben de seguir para distinguir un razonamiento correcto de un razonamiento incorrecto. La lógica proposicional investiga la relación entre una serie de premisas y una conclusión, de esta manera se sabe que una conclusión es verdadera si es consecuencia de sus premisas.
En la lógica proposicional, los conectivos lógicos son tratados como funciones de verdad. Es decir, como funciones que toman conjuntos de valores de verdad y devuelven valores de verdad.
Negación
NO,NOT
Conjunción
Y, AND
Disyunción
O, OR
Implicación
si... entonces
Las tortugas
NO
vuelan
Los colibríes vuelan Y las serpientes se arrastran. Eres gordo SI pesas
O
eres flaco.
90 Kilogramos ENTONCES tienes sobrepeso.
Al observar los ejemplos anteriores, si el lector tiene conocimientos previos de programación habrá notado cierta similitud al razonamiento que se utiliza al realizar algoritmos computacionales. Esto es debido a que buena parte de la lógica proposicional es utilizada en las ciencias de la computación como medio para contar con un razonamiento mediante sentencias de un lenguaje más 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 lógico. Cada premisa es representada por la letra P y la letra Q, estas pueden ser verdaderas 10
o falsas. La conclusión de las premisas entonces, depende del conectivo que se le aplica. A continuación se muestran las tablas de verdad de algunas de las premisas previamente mostradas.
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 representación de los conectivos lógicos básicos viene dada por las siguientes expresiones: || ( OR), && ( AND) y not (Not ) Para que la utilización de la lógica proposicional quede más clara, mostraremos algunos ejemplos de su utilización en el lenguaje de programación Haskell. Mediante el previo conocimiento del conectivo lógico de disyunción (Ó), el cual desde ahora llamaremos OR, construiremos un conectivo más 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 demás configuraciones posibles da como resultado una conclusión falsa. La tabla de verdad que representa a XOR es la siguiente:
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 función XOR es el siguiente: 11
Haskell xor.hs Función que se comporta como el conectivo lógico XOR xor :: Bool -> Bool -> Bool --Definición de función: recibe 2 --booleanos y retorna uno. xor x y = ( x || y) && not ( x && y) – XOR es un OR mo dificado, devuelve --verdade ro para las mismas combi naciones que OR, exceptua ndo aquellas donde --ambas preposiciones son verdaderas
, es un conec tivo definido en la librería prelude. El siguiente ejemplo muestra la forma en que funciona.
:
Haskell
negación.hs
Función que se comporta como el conectivo lógico NOT contrario :: Bool -> Bool --Definición de la función, únicamente recibe un --booleano para retornar otro contrario x = not x
:
--invierte el valor del parámetro booleano.
Haskell diferentes.hs Función que indica si 3 variable son diferentes.
--Se declara que la función recibirá 3 enteros para devovler un booleano. threeDifferent :: Integer -> Integer -> Integer ->Bool --Para que todos los números sean iguales se tienen que cumplir las --condici ones siguient es threeDiff erent a b c= (a/=c)&& ( (c/=b)&& (b/=a) )
12
4. TIPOS DE DATOS Como en cualquier lenguaje de programación, Haskell posee diferentes tipos de datos. A diferencia de algunos lenguajes, Haskell está estrictamente tipado, esto quiere decir que en una función, 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 compilación. Son utilizados para representar fracciones. Un número se toma como flotante cuando incluye un punto. Si el número que se quiere representar no necesita una gran precisión, es recomendable utilizar Float, si es necesaria una buena precisión se utiliza double . Haskell define algunas funciones para trabajar con números de coma flotante. Representa el número pi Devuelve el logaritmo del número que se le envía como parámetro. Devuelve la r aíz cuadrada del número enviado como parámetro. Devuelve el seno del parámetro. Devuelve el Coseno de l parámetro. Devuelve la Tangente del parámetro. : Devuelve el arco Seno del parámetro. Devuelve el arco Coseno del parámetro. Devuelve el arco Tangente del parámetro. A continuación se muestran algunos ejemplos de la utilización de los tipos de coma flotante:
Haskell circunfer encia.hs Función para calcular la circunfer encia de un círculo circun :: Double -> Double retorna un Double. circun d = (pi*d)
--Definición de función: Recibe un tipo Double y
--El número que recibe es multiplicado por la pi (definido en haskell por --defecto).
13
Haskell promedio1.hs Calculo del promedio de tres números. promedio :: Int-> Int
-> Int -> Float
--Definición
de función: 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.
Haskell promedio2.hs Calculo del promedio de tres números, también dice cual parámetro recibido es mayor a este promedio. main=do
putStrLn "num1: " num1 <- getInt putStrLn "num2: " num2 <- getInt putStrLn "num3: " num3 <- getInt
--Función principal -- Imprime ‚num:1‛ --Recibe de teclado y lo guarda en num1
-- Imprime la cadena --Recibe de teclado --Imprime la cadena --Recibe de teclado
let p = (promedio num1 num2 num3)
‚num2‛ y lo guarda en num2
‚num3‛ y lo guarda en num3
--Almacena el resultado de ejecutar la función --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 función promedioM (cuya descripción aparece abajo) pasándole –cada uno de los parámetros. putStrLn("Prom= "++show(p)++"\n"++(promedioM num1 p)++(promedioM num2 p)++(promedioM num3 p)) promedio :: Int-> Int
-> Int -> Float
--Definición de función; 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 retornar un Float
--Definición de función; recibe tres enteros para
--las funciones de abajo definen lo que se debe hacer para las condiciones, el parámetro recibido es mayor que el --parámetro del tipo Float recibido (promedio) promedioM num prom |fromIntegral(num)>prom =""++(show num)++"> prom "++"\n" promedioM num prom |fromIntegral(num)
14
Haskell pulagadas.hs : Programa que conv ierte centímetros a pu lgadas. pulgada = 25/64
--Se declara pulgada con su equivalente en cms, aunque no se declar a explícitam ente que es --u n tipo de com a flotante, el valor 25/64 se lo da por entendido al
‚compilador‛. cmaPulgadas :: Double-> Double retornar un Double cmaPulga das n= (n*pulga da)
--Definición de función: Se pide un Double para --El parámetro n es multiplic ado por la función -- ‚pulgada‛.
String, son secuencias de „ Char„ encerradas en comillas dobles “ ”,en otras palabras, un String, es una lista que contiene la representación de un caracter (que a su vez representa un código en la tabla ASCII) en cada posición. Al ser una lista, los tipos String pueden utilizar cualquier función predefinida para las listas. : Retorna el elemento en la posición n : Retorna el primer elemento. : Retorna el útlimo elemento. : Retorna todos los elementos menos el primero. : Retorna un entero que representa el largo de la lista. : Retorna la misma lista pero en o rden invertido. : Retorna palabras separadas por espacio
Lo siguientes programas, son ejemplos de la utilización de cadenas de caracteres en Haskell:
15
Haskell invertir.hs : Se le manda como parámetro un String, y lo devuelve invertido main = do
--Función principal --para escribir varias sentencias en la misma función putStrLn " Introduce una cadena de texto" --Imprime la cadena texto <- getLine --Espera a que sea escrita una linea por --teclado y la --almace na en text o
--Imprime el resultado de ejecutar la función -- ‚voltea r‛ mandándole como parámet ro el t exto recibido putStrLn ("La cadena alreves es : "++voltear texto) voltear :: String -> String --Definición de función: Se espera un String para retornar un String voltear tex = reverse tex
-- el parámetro recibido ‚tex‛ se envía a la
función predefinida ‚reverse‛
Haskell largo.hs Se le manda una cadena y retorna el largo de esta.
posicion :: String -> Int String y retorna un Int posicion cad = length cad
--Definición de función que recibe un --El parámetro recibido e enviado a la función --lenght, la cual retorna un entero --con el largo de la cadena, o lista.
Una lista es una secuencia de valores de algún tipo en específico, 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‟,]
16
En Haskell también se pueden definir listas de listas (matrices). Al declarar una función a la cual se le envía como parámetro una lista, se debe definir la cola y la cabeza de la lista
Haskell enésimo.hs La función enésimo devuelve el elemento deseado de una lista de enteros enesimo :: Int -> [Int] -> Int
--Definición
de
función;
recibe un entero y una lista de enteros, retorna otro entero enesimo 1 (c:cola) = c enesimo n (c:cola) = enesimo (n-1) cola
Una tupla es un tipo de dato compuesto. A diferencia de las listas el número de componentes es fijo y los pueden ser cada uno de un tipo distinto. Las tuplas son creadas con paréntesis, donde los elementos van dentro sep arados por comas. Ejemplo: (“Tomate”, 18): donde tomate representa el producto y 18 el precio.
Ejemplos del manejo de algunas Tuplas.
Haskell tupla1.hs 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 números recibidos en la tupla son --sumados y se retornan en un solo numero.
17
Haskell shift.hs Recibe números agrupados en 2 tuplas dentro de otra, devuelve los mismo números agrupados de forma distinta. --Se necesita como parámetro una tupla con dos números enteros, la --cual estará dentro de otra tupla que necesita otro número entero. --se retorna algo parecido al parámetro 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 agrupación.
Haskell tupla2.hs Se le ingresan dos números que son devueltos ordenados de menor a mayor dentro de una tupla. --Se definen como parámetros dos enteros, se retorna una tupla de dos enteros.
minAndMax :: Integer -> Integer -> (Integer, Integer) minAndMax x y |x>= y |otherwise
--Los parámetros se nombran como x e y =(y,x) --Si x es mayor que y se retorna lo que se -- indica = x --si no se retorna en orden contrario
Mediante la utilización de la palabra reservada y las Tuplas se pueden declarar nuevos tipos de datos que se adapten a nuestras necesidades. Un ejemplo de esto sería:
Haskell tupla3.hs Muestra el nombre o el precio de algún Item que se le envía 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 price :: ShopItem -> Int
name (n, p) =n price (n,p) =p
--name requiere un ShopItem y retorna --un Str ing --price requiere un ShopIem y retorna --un ent ero
--Retorna el elemento n --Retorna el elemento p
18
Haskell maxOccurs.hs Retorna el nú mero que e s may or, junto a la cantidad de veces que es repetido
maxOccurs ::Integer -> Integer -> maxOccurs a b |a>b = (a,1) |a
Haskell
(Integer, Integer)
maxoccu rs2.hs
Muestra el valor mas alto entre tres números y retorna el número de veces que aparece.
maxTres :: I nteger -> Integer ->Integer -> (Integer, Integer) maxTres a b c = (x,y) where --x llama a la función comparación, la cual --retorna el mayor de a b y c x= comparacion [a,b,c] --y llama a la función ocurrencias, la cual -- cuenta el numero de ve ces que aparece x y= ocurrencias x [a,b,c]
comparacion :: [Integer] -> Integer comparacion [] = er ror "Ningún elemento" comparacion [x] = x comparacion (x:cola) | x > maxTail = x | otherwise = maxTail where maxTail = comparacion cola ocurrencias :: Int eger -> [Integer]->Integer ocurrencias a []=0 --La condición 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)
19
Las variables en Haskell se declaran mediante la utilización de
y
.
En Haskell las variables son definidas estrictamente como variables matemáticas, 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 definición de la función.
Haskel l cuadrad oSuma.hs Función que calcula el cuadrado de un parámetro, utiliza la sentencia where. sumSquares :: Integer -> Integer -> Integer función, recibe dos enteros y retorna otro sumSquares n m se nombran n y m = sqN + sqM de sqN y sqM
--Definición de --Los parámetros que recibe --El resultado será la suma
where declaran los valores de sqN y sqM sqN= n*n sqM= m*m
--Con esta sentencia se --sqN se declara como n*n --sqM se declara como m*m
20
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 librería prelude. Contiene un conjunto de operaciones para manejar secuencias aritméticas. Los tipos de datos que pueden aceptar las operaciones contenidas en Enum, son la mayoría de los tipos numéricos, además de los Char, ya que estos últimos son realmente un número que representa un carácter según la tabla del código ASCII. Algunas de las funciones más importantes contenidas en enum son: : es equivalente a [n..]. „n‟ es el primer elemento de la lista, a part ir de donde se enumeran los elementos existentes hasta donde es posible. : es equivalente a la sentencia [a,n..] . : es equivalente a la sentencia [a,n...o], donde „a‟ es el número en donde comienza la enumeración, n es el segundo número de la enumeración, „o‟ es el último, los números intermedios van aumentando “n – a” hasta llegar a „o ‟ : la sentencia equivalente es [a…n]. Donde „a‟ es el primer elemento, después los elementos entre „a‟ y „n‟ son enumerados, n es el último
elemento que se mostrará. Ejemplos:
Haskell enum1.hs Función que imprime los caracteres existentes entre a y n, en la tabla de codificación 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 incluyénd olos
21
Haskell enum2.hs Función que cuenta desde a hasta n saltando números. enumerarS altos ::Int -> In t ->In t-> [Int] --recibe 3 enteros, retorna una --lista de enteros --Es equivalente a decir, contar desde a hasta n de s en s saltos enumerarS altos a n s= enumFromT henTo a s n
22
CONCLUSIÓN. El uso de la programación funcional, como nos pudimos dar cuenta en los ejercicios realizados, nos brinda una forma de programación en la cual nos enfocamos más en el diseño del algoritmo que en los detalles técnicos del propio lenguaje. Además de esto, nos da la posibilidad de ver el desarrollo del programa, como un desarrollo de fórmulas matemáticas, por lo que es más fácil programar nuestras ideas. Todo esto junto a la utilización de menos líneas de código. De las características más notables de Haskell destacan: La ausencia de ciclos, estos son sustituidos por llamadas recursivas de las funciones. Otra característica es la imposibilidad de modificar el valor de una variable previamente declarada dentro de una función, esto puede sonar algo extraño si estamos acostumbrados a la POO, donde este rasgo es una de las características principales, pero si comparamos la definición matemática de función vemos que es más acertada la definición del paradigma funcional. En estas prácticas, apenas se definen conceptos básicos de Haskell, se espera que más adelante se aborden temas muy importantes como el manejo de hilos.
23
BIBLIOGRAFÍA
Borrego, Silvia.(2009) Lógica Proposicional
Fokker, Jeroen. (1996) Programación 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) Introducción al lenguaje Haskell
Rico R. Vicente. (2011) Paradigmas de programación.
Rivadera, Gustavo. (2008) La programación funcional: Un poderoso paradigma
24
