7/25/2019 Terico Unidad 6
1/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
NIDAD N 6:
PARADIGMA FNCIONAL
2013
EL PRESENE CAPLO HA SIDO ELABORADO,CORREGIDO COMPILADO POR:
CASILLO,JLIOGMAN,ANALALIGORRIA,LARA
MARCISACK,MARCELOMOSCHK,JORGE
7/25/2019 Terico Unidad 6
2/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 1
NDICE
................................................................................................................. 3
................................................................................................................ 3
1. PARADIGMA FNCIONAL ............................................................................................................... 4
1.1 Introduccin ................................................................................................................................ 4
................................................................................................................. 4
................................................................................................................ 4
1.2 Historia ........................................................................................................................................ 5
1.3 Caractersticas ............................................................................................................................. 7
1.4 Ventajas y Limitaciones ............................................................................................................... 8
1.5 reas de aplicacin ..................................................................................................................... 8
1.6 Ejemplos de implementaciones .................................................................................................. 9
1.7 Familia de lenguajes en el Paradigma Funcional ........................................................................ 9
1.8 Conceptos generales ................................................................................................................... 9
1.8.1 Repaso de Funcin matemtica ........................................................................................... 10
1.8.2 Funciones: Sintaxis en el Paradigma Funcional .................................................................... 11
1.8.3 Abstraccin funcional ........................................................................................................... 12
1.8.4 Funcin de Orden Superior................................................................................................... 13
1.8.5 LambdaCalculo .................................................................................................................... 14
1.8.6 Evaluacin Pereosa(Lay) .................................................................................................... 15
2. EL LENGAJE HASKELL .................................................................................................................. 16
2.1 Introduccin .............................................................................................................................. 16
2.1.1 Por que usar Haskell? ......................................................................................................... 16
2.1.2 Haskell en accin .................................................................................................................. 17
2.2 Tipos de datos ........................................................................................................................... 17
2.2.1 Sistema de inferencia de tipos ............................................................................................. 17
2.2.2 Tipos predefinidos ................................................................................................................ 18
2.3 Funciones ................................................................................................................................ 200
7/25/2019 Terico Unidad 6
3/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 2
2.4 El entorno de Haskell HUGS .................................................................................................... 22
2.4.1 Elementos de Hugs ............................................................................................................... 24
2.4.2 Comandos de Hugs ............................................................................................................... 25
2.4.3 Mdulos .............................................................................................................................. 266
2.5 Sintaxis de Haskell ..................................................................................................................... 27
2.5.1 Case sensitive ..................................................................................................................... 277
2.5.2 Comentarios ....................................................................................................................... 277
2.5.3 Valores ................................................................................................................................ 277
2.5.4 Expresiones ........................................................................................................................... 28
2.5.5 Identificadores .................................................................................................................... 288
2.5.6 Operadores ......................................................................................................................... 288
2.5.7 Expresiones ifthenelse ....................................................................................................... 29
2.5.8 Expresiones case ................................................................................................................. 300
2.5.9 Expresiones con guardas .................................................................................................... 300
2.5.10 Definiciones locales ........................................................................................................ 322
Expresiones Let. .............................................................................................................................. 32
Expresiones Where ......................................................................................................................... 32
2.5.11 Disposicin del cdigo: Espaciado (layout) .................................................................... 333
2.5.12 Expresiones recursivas ................................................................................................... 344
2.5.13 Expresiones ......................................................................................................... 35
2.6 Tipos de datos compuestos .................................................................................................... 355
2.6.1 Tuplas ................................................................................................................................. 355
2.6.2 Listas ................................................................................................................................... 3662.7 Tipos definidos por el usuario ................................................................................................... 39
2.7.1 Sinnimos de tipo ................................................................................................................. 39
2.7.2 Definiciones de tipos de datos ............................................................................................. 39
Tipos Producto................................................................................................................................ 40
7/25/2019 Terico Unidad 6
4/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 3
2.8 Tipos Polimrficos ................................................................................................................... 411
2.9 Tipos Recursivos ...................................................................................................................... 422
2.10 Sobrecarga y Clases en Haskell ............................................................................................... 433
3. ANEO I LA ENSEANA DE HASKELL .................................................................................... 466
4. BIBLIOGRAFA .............................................................................................................................. 47
7/25/2019 Terico Unidad 6
5/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
1.PARADIGMA FNCIONAL
1.1 INRODCCIN
El paradigma funcional es un paradigma declarativo que se basa en un modelo matemtico de
composicin de funciones. En este modelo, el resultado de un clculo es la entrada del siguiente, y as
sucesivamente hasta que una composicin produce el valor deseado, tal como sucede en la composicin
de funciones matemticas.
Los programas funcionales expresan mejor qu hay que calcular, y no detallan tanto cmo realiar dicho
clculo a diferencia de lo que ocurre en los programas imperativos.
EvaluadorUsuario
Expresin
Valor
Intrprete/Compilador
Evaluacin
Cdigo
Definicionesde funciones
Programador
La caracterstica principal de la programacin funcional es que los clculos se ven como una funcin
matemtica que hacen corresponder entradas y salidas.
Que el alumno comprenda acabadamente los principios constitutivos y filosficos que dan origen a
este paradigma.
Que el alumno utilice el concepto de funciones para la construccin de programas en la resolucin
de problemas.
Concepto de funcin matemtica y su empleo en un lenguaje de programacin. La funcin como
bloque de construccin de programas. Concepto de programa en el paradigma funcional. El Clculo
lambda, concepto de funciones de orden superior, manejo y concepto de variables. Funciones
recursivas. Manejo de listas. Funciones de orden superior. Sistemas de tipos. Polimorfismo y tipos
genricos. Expresiones lambda.
Lenguaje: Haskell
7/25/2019 Terico Unidad 6
6/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 5
No existe el concepto de celda de memoria que es asignada o modificada. Ms bien, existen valores
intermedios que son el resultado de cmputos intermedios, los cuales resultan en valores tiles para los
clculos subsiguientes.
Tampoco existen sentencias imperativas(al menos en un lenguaje de programacin funcional puro) y
todas las funciones tienen transparencia referencial, es decir, el resultado devuelto por una funcin slo
depende de los argumentos que se le pasan en esa llamada.
La idea de repeticin se modelautiliando la recursividad ya que no que no existe el concepto de valor
de una variable.
1.2 HISORIA
Los orgenes tericos del modelo funcional se remontan a los aos 30 en los cuales Church propuso un
nuevo modelo de estudio de la computabilidad mediante el . Este modelo permita
trabajar con funciones como objetos de primera clase. En esa misma poca, Shnfinkel y Curry
construan los fundamentos de la lgica combinatoria que tendr gran importancia para la
implementacin de los lenguajes funcionales.
Hacia 1950, John McCarthy dise el lenguaje LISP (List Processing) que utiliaba las listas como tipo
bsico y admita funciones de orden superior. Este lenguaje se ha convertido en uno de los lenguajes
ms populares en el campo de la Inteligencia Artificial. Sin embargo, para que el lenguaje fuese prctico,
fue necesario incluir caractersticas propias de los lenguajes imperativos como la asignacin destructiva
y los efectos laterales que lo alejaron del paradigma funcional. Actualmente ha surgido una nueva
corriente defensora de las caractersticas funcionales del lenguaje, encabeada por el dialecto S,que aunque no es puramente funcional, se acerca a la definicin original de McCarthy.
En 1964, P Ldise la mquina abstracta SECD para mecaniar la evaluacin de expresiones,
defini un subconjunto no trivial de Algol60 mediante el clculo lambda e introdujo la familia de
ISIM(If You See What I Mean) con innovaciones sintcticas (operadores infijos y espaciado)
y semnticas importantes.
En 1978 J. B (uno de los diseadores de FORTRAN y ALGOL) consigui que la comunidad
informtica prestara mayor atencin a la programacin funcional con su artculo Can Programming be
liberated from the Von Neumann style? en el que criticaba las bases de la programacin imperativa
tradicional mostrando las ventajas del modelo funcional.
Adems Backus dise el lenguaje funcional FP (Functional Programming) con la filosofa de definirnuevas funciones combinando otras funciones.
A mediados de los 70, Gtrabajaba en un sistema generador de demostraciones denominado LCF
que inclua el lenguaje de programacin ML(Metalenguaje). Aunque el sistema LCF era interesante, se
observ que el lenguaje ML poda utiliarse como un lenguaje de propsito general eficiente. ML optaba
por una solucin de compromiso entre el modelo funcional y el imperativo ya que, aunque contiene
asignaciones destructivas y Entrada/Salida con efectos laterales, fomenta un estilo de programacin
7/25/2019 Terico Unidad 6
7/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 6
claramente funcional. Esa solucin permite que los sistemas ML compitan en eficiencia con los lenguajes
imperativos.
A mediados de los ochenta se reali un esfuero de estandariacin que culmin con la definicin de
SML(Stndar ML). Este lenguaje es fuertemente tipado con resolucin esttica de tipos, definicin de
funciones polimrficas y tipos abstractos. Actualmente, los sistemas en SML compiten en eficiencia con
los sistemas en otros lenguajes imperativos.
A comienos de los ochenta surgieron una gran cantidad de lenguajes funcionales debido a los avances
en las tcnicas de implementacin. Entre stos, se podran destacar Hope, LML, Orwell, Erlang, FEL, Alfl,
etc. Esta gran cantidad de lenguajes perjudicaba el desarrollo del paradigma funcional. En septiembre de
1987, se celebr la conferencia FPCA en la que se decidi formar un comit internacional que disease
un nuevo lenguaje puramente funcional de propsito general denominado Haskell.
Con el lenguaje H se pretenda unificar las caractersticas ms importantes de los lenguajes
funcionales, como las funciones de orden superior, la evaluacin pereosa, la inferencia esttica de
tipos, los tipos de datos definidos por el usuario, el encaje de patrones y las listas por comprensin. Al
disear el lenguaje se observ que no exista un tratamiento sistemtico de la sobrecarga con lo cual se
construy una nueva solucin conocida como las clases de tipos.
El lenguaje incorporaba, adems, Entrada/Salida puramente funcional y definicin de arrays por
comprensin.
Durante casi 10 aos aparecieron varias versiones del lenguaje Haskell, hasta que en 1998 se decidi
proporcionar una versin estable del lenguaje, que se denomin Haskell98, a la ve que se continuaba la
investigacin de nuevas caractersticas y nuevas extensiones al lenguaje.
A continuacin veremos grficamente la evolucin de los ms importantes lenguajes de programacin:
7/25/2019 Terico Unidad 6
8/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 7
1.3 CARACERSICAS
Transparencia referencial: permite que el valor que devuelve una funcin est nicamente
determinado por el valor de sus argumentos consiguiendo que una misma expresin tenga
siempre el mismo valor. De esta manera, los valores resultantes son inmutables. No existe el
concepto de cambio de estado.
Utiliacin de tipos de datos genricos: permite aumentar su flexibilidad y realiar unidades de
software genricas, es una forma de implementar el polimorfismo en el paradigma funcional.
Recursividad: Basada en el principio matemtico de induccin, que se ve expresada en el uso
de tipos de datos recursivos, como las listas, y funciones recursivas que las operan.
Posibilidad de tratar a las funciones como datos mediante la definicin de funciones de orden
superior, que permiten un gran nivel de abstraccin y generalidad en las soluciones. El usocorrecto de las funciones de orden superior puede mejorar substancialmente la estructura y la
modularidad de muchos programas.
Los lenguajes funcionales relevan al programa de la compleja tarea de gestin de memoria. El
almacenamiento se asigna y se inicialia implcitamente, y es recuperado automticamente por
un recolector de la basura (garbage collector). La tecnologa para la asignacin de memoria y de
la recoleccin de la basura estn actualmente bien desarrollados por lo que su costo de
funcionamiento es leve.
7/25/2019 Terico Unidad 6
9/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 8
La manera de construir abstracciones es a travs de funciones, ya que no existen los conceptos
de variables o el concepto de cambio de estado.
Basado en la matemtica y en la teora de funciones.
1.4 ENAJAS LIMIACIONES
Se enumeran a continuacin algunas de las ventajas y limitaciones de trabajar con este paradigma.
Fcil de formular matemticamente.
Administracin automtica de la memoria.
Simplicidad en el cdigo.
Rapide en la codificacin de los programas.
L
No es fcilmente escalable.
Difcil de integrar con otras aplicaciones.
No es recomendable para modelar lgica de negocios o para realiar tareas de ndoletransaccionales.
1.5 REAS DE APLICACIN
El paradigma funcional tiene diversas reas de aplicacin entre las cuales podemos enumerar a las
siguientes:
Demostraciones de teoremas: Por su naturalea funcional este paradigma es til es en la
demostracin automtica de teoremas, ya que permite especificar de manera adecuada yprecisa problemas matemticos.
Creacin de compiladores, analiadores sintcticos: Su naturalea inherentemente recursiva le
permite modelar adecuadamente estos problemas.
Resolver problemas que requieran demostraciones por inducciones.
En la industria se puede usar para resolver problemas matemticos complejos.
7/25/2019 Terico Unidad 6
10/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 9
Se utilia en centros de investigaciones y en universidades.
1.6 EJEMPLOS DE IMPLEMENACIONES
A continuacin se detallan algunas implementaciones exitosas en la industria:
ABN AMRO Amsterdam: Es un banco internacional con sede en msterdam. Para sus
actividades de banca de inversin necesita medir el riesgo de ciertos agentes financieros, para
ello utilia Haskell.
Amgen en Thousand Oaks: Compaa Californiana que se desarrolla en la industria teraputica
y en biotecnologa. Amgen fue pionera en el desarrollo de nuevos productos basados en los
avances en la recombinacin del ADN y en biologa molecular. Amgen utilia Haskell para lograr
una rpida creacin de productos software que implemente modelos matemticos complejos yque les permita realiar una validacin matemtica rigurosa.
Antope Fair Haven: Compaa de Nueva Jersey (USA) que se desempea en la industria de la
comunicacin inalmbrica y redes. Realian diseo de sistemas inalmbricos, desde la capa
fsica y las dems capas de protocolo de red. Utilian Haskell para realiar programas de
simulacin y modelar los diseos de hardware.
Ericsson: Ericsson utilia Haskell para la implementacin de algoritmos de procesamiento digital
de seales.
1.7 FAMILIA DE LENGAJES EN EL PARADIGMA FNCIONAL
Todos los lenguajes funcionales estn basados en el LambdaCalculo. De hecho su influencia es evidente
en lenguajes de programacin funcionales como Lisp, Hope, Miranda, Haskell, ML y Scheme. El lambda
clculo provee de una sintxis bsica para definir primitivas de programacin y usa el concepto de
funcin matemtica para transformar argumentos en resultados.
El lenguaje Lisp ideado por John McCarthy fue el primer lenguaje de programacin funcional y fue el
nico por muchos aos. Aunque todava se usa Lisp, no es un lenguaje que rena las exigencias. Debido
a la creciente complejidad de los programas de ordenador, se hio necesaria una mayor verificacin del
programa por parte del ordenador. En los aos ochenta se crearon un gran nmero de lenguajesfuncionales tipados. Algunos ejemplos son ML, Scheme (una adaptacin de Lisp), Hope y Miranda.
Los lenguajes ML y Scheme tienen tambin muchos seguidores. Estos lenguajes han hecho algunas
concesiones en la direccin de los lenguajes imperativos. Un grupo de investigadores notables concibi
un lenguaje que inclua todas las mejores cualidades de los diferentes lenguajes. Este lenguaje se llama
Haskell y es puramente funcional de propsito general.
1.8 CONCEPOS GENERALES
7/25/2019 Terico Unidad 6
11/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 10
1.8.1 REPASO DE FNCIN MAEMICA
es una regla de asociacin que relaciona dos o ms conjuntos entre si; generalmente
cuando tenemos la asociacin de dos conjuntos las funcin se define como una regla de asociacin
entre un conjunto llamado dominio con uno llamado codominio o imagen.
Expresado de otra manera, una funcin f entre dos conjuntos A y B, es una correspondencia
que a cada elemento de un subconjunto de A, llamado Dominio de f, le hace corresponder uno y slo
uno de un subconjunto B llamado Imagen de f.
: A B
f es una funcin de A en B, o f es una funcin que toma elementos del dominio A y los aplica
sobre otro llamado imagen B.
Se dice que el son todos los valores que puede tomar el conjunto del
dominio y que encuentra correspondencia en el conjunto llamado imagen, generalmente cuando se
habla del plano, el dominio es el intervalo de valores que estn sobre el eje de las Xs y que nos generan
una asociacin en el eje de las Ys.
El otro conjunto que interviene en la definicin es el conjunto llamado
, este conjunto es la gama de valores que puede tomar la funcin; en el caso del plano sontodos los valores que puede tomar la funcin o valores en el eje de las Ys.
Tambin, cuando se grafica en el plano cartesiano se tiene una relacin de dos variables,
considerando como variable aquella literal que esta sujeta a los valores que puede tomar la otra.
Usualmente las funciones se expresan con la siguiente sintaxis
() = 2 *
7/25/2019 Terico Unidad 6
12/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 11
donde:
x: argumento nominal que representa a los elementos del Dominio
f: nombre de la funcin
En el lado derecho se representa el elemento del codominio o imagen o la forma de obtenerlo.
Generalmente, para calcular la imagen de x a partir de f, deben usarse otras funciones, las
cuales tambin debern definirse, por ejemplo.
f(x) = 2 * x
g(x) = f(x) + 4
donde f, g, *, + son funciones
En general:
1. Las funciones establecen relaciones entre dos conjuntos, imponiendo la restriccin nica de
que un elemento no puede tener dos imgenes,
2. La definicin de funciones es una estructura jerrquica, en la cual las funciones ms simples
aparecen en la definicin de las funciones ms complejas.
3. En las definiciones, las funciones utiliadas a la derecha del signo de igualdad se referencian
solo por su nombre. El significado puede obtenerse de reemplaar el nombre por su definicin.
4. Esta sucesin se clausura con funciones primitivas, cuyo significado se da por sobreentendido.
5. Bsicamente se aplican los conceptos del diseo modular, en el cual un problema complejo sedescompone en problemas ms simples.
6. Cada uno de ellos es un problema primitivo, o bien, deber volver a descomponerse.
7. La facilidad de referenciar una funcin por su nombre, permite que la misma sea empleada sin
tener la necesidad de conocer su estructura interna.
8. Esta estrategia permite disear realiando refinamientos sucesivos.
9. La estructura de un mdulo complejo puede definirse, sin que necesariamente estn definidos
los mdulos componentes.
1.8.2 FNCIONES:SINAIS EN EL PARADIGMA FNCIONAL
En el esquema funcional, las funciones se denominan expresiones y se pueden representar con
la siguiente sintaxis:
::=
7/25/2019 Terico Unidad 6
13/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 12
(, ... ,)
(, ... ,)
Todas las expresiones denotan un valor, pueden ser expresiones que no admitan ser aplicadas a
ningn argumento, ya que estn totalmente evaluadas o expresiones que pueden ser aplicadas a un
cierto nmero de argumentos para ser totalmente evaluadas.
Las formas permitidas por la gramtica son:
A. expresiones atmicas, que pueden ser y
B. expresiones compuestas
abstracciones funcionales: (, . . .,)
aplicaciones funcionales: (, . ,)
1.8.3 ABSRACCIN FNCIONAL
Una abstraccin funcional es una expresin por la cual se define una funcin. Considrese la
siguiente expresin:
3*5
mediante una abstraccin funcional puede construirse una expresin de tal forma que el
producto anterior sea un caso particular de sta.
Por ejemplo:
(x) 3 * x
es una forma ms general, y mediante una aplicacin de la misma puede obtenerse la
expresin original. Tambien se podra generaliar ms la abstraccin funcional, expresando:
(x, y) x * y
donde la definicin de la funcin o abstraccin funcional cumple con la construccin general:
(, .... ,)
Tambin se puede expresar la abstraccin funcional de la siguiente forma:
( x ) ( y )
tanto ( y ) como ( x ) ( y ) son abstracciones funcionales. Esta opcin
indicara que la imagen ser una funcin de y.
7/25/2019 Terico Unidad 6
14/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 13
1.8.4 FNCIN DE ORDEN SPERIOR
Es una funcin tal que alguno de sus argumentos es una funcin o que devuelve una funcin
como resultado.
Son tiles porque permiten capturar esquemas de cmputo generales (abstraccin).
Son ms tiles que las funciones normales (parte del comportamiento se especifica al usarlas).
Por ejemplo:
Definimos una funcin que invoque a otra funcin dos veces, por ejemplo el incremento en 1.
Para expresar est funcin colocamos en el primer argumento, en lugar de una variable, una funcin
llamada f, quedando la siguiente expresin:
(f ,x) f (f x) (f) (x) f ( f (x) )
donde:
f representa la expresin o funcin.
x es una variable.
(x) f ( f (x) ) es una abstraccin funcional (que posee la variable x y la expresin f ).
f ( f (x) ) es una abstraccin funcional (define la expresin f).
f (x) es una aplicacin funcional (define el cuerpo de la abstraccin funcional anterior).
esta expresin indicara que, la imagen de la funcin sobre la variable f es una funcin sobre la
variable x que aplica dos veces f a x
Si asociamos un nombre a esta funcin:
dos_veces = (f) (x) f (f x)
donde:
( x ) f( f(x) ) es la expresin
y ( f ) ( x ) f( f(x) ) la abstraccin funcional
Si consideramos la funcin inc (que incrementa en 1 un valor), por ejemplo:
inc = (x) x+1
Si asociamos f con la funcin inc, la imagen de inc de acuerdo a dos_veces sera:
7/25/2019 Terico Unidad 6
15/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
dos_veces (inc) ===> (x) inc( inc(x) )
la aplicacin de dos_veces a una funcin da como resultado otra funcin, la cual obviamente puede
aplicarse a su ve a otro valor.
Si probamos con el valor de x = 3:
(dos_veces (inc)) 3 ===> (3) inc( inc(3) )
4
5
===> 5
En este ejemplo podemos destacar que los argumentos y resultados de la aplicacin de
funciones pueden ser a su ve funciones, las cuales pueden ser tambin aplicadas a otros argumentos.
Este tipo de funcin es denominado FUNCIN DE ORDEN SUPERIOR denotando el hecho quesus argumentos y resultados pueden ser funciones.
1.8.5 LAMBDACALCLOClculo lambda: es un sistema formal diseado para investigar la definicin de funcin, la nocin de
aplicacin de funciones y la recursin. Se puede considerar al clculo lambda como el ms pequeo
lenguaje universal de programacin. Consiste de una regla de transformacin simple (substitucin de
variables) y un esquema simple para definir funciones.
El clculo lambda es universal porque cualquier funcin computable puede ser expresada y evaluada a
travs de l. Church redujo todas las nociones del clculo de sustitucin.
Normalmente, un matemtico debe definir una funcin mediante una ecuacin.
Por ejemplo, si una funcin f es definida por la ecuacin f(x)=t, donde t es algn trmino que contiene a
x, entonces la aplicacin f(u) devuelve el valor t[u/x], donde t[u/x] es el trmino que resulta de sustituir
u en cada aparicin de x en t.
Por ejemplo, si f(x)=x*x, entonces f(3)=3*3=9.
Lambda Expresiones
Church propuso una forma especial (ms compacta) de escribir estas funciones. En ve de decir la
funcin f donde f(x)=t, l simplemente escribi \x.t.
Para el ejemplo anterior: \x.x*x.
Un trmino de la forma \x.t se llama lambda expresin. La principal caracterstica de lambdaclculo es su simplicidad ya que permite efectuar solo dos operaciones:
Definir funciones de un solo argumento y con un cuerpo especifico, denotado por la siguiente
terminologa: x.B, en donde x determina el parmetro o argumento formal y B representa el cuerpo de
la funcin, es decir f(x) = B.
7/25/2019 Terico Unidad 6
16/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Ejemplo 1:
Para la funcin
f: A B
f(x) 2x + 1
Podemos escribirla como una expresin de la forma
x . 2x+1
Ejemplo 2:
f(x, y) = (x + y)*2
Se expresara en Calculo como
x. y. * (+ x y) 2
Aplicar alguna de las funciones definidas sobre un argumento real (A); lo que es conocido tambin con el
nombre de reduccin, y que no es otra cosa que sustituir las ocurrencias del argumento formal (x), que
aparecan en el cuerpo (B) de la funcin, con el argumento real(A), es decir: (x.B) A
Ejemplo 3:
( x. (x+5) ) 3
Lo que indica que en la expresin x+5, se debe sustituir el valor de x por 3.
Los dos mecanismos bsicos presentados anteriormente se corresponden con los conceptos de
abstraccin funcional y aplicacin de funcin; si le agregamos un conjunto de identificadores para
representar variables se obtiene lo mnimo necesario para tener un lenguaje de programacin funcional.
El clculo Lambda tiene el mismo poder computacional que cualquier lenguaje imperativo tradicional.
1.8.6 EALACIN PEREOSA(LA)
Los lenguajes tradicionales, evalan todos los argumentos de una funcin antes de conocer si stos
sern utiliados. Dicha tcnica de evaluacin se conoce como evaluacin ansiosa ( )
porque evala todos los argumentos de una funcin antes de conocer si son necesarios.
Por otra parte, en ciertos lenguajes funcionales se utilia evaluacin pereosa ( ) queconsiste en no evaluar un argumento hasta que no se necesita.
Haskell, Miranda y Clean son pereosos, mientras que LISP, SML, Erlang y Scheme son estrictos.
Uno de los beneficios de la evaluacin pereosa consiste en la posibilidad de manipular estructuras de
datos 'infinitas'. Evidentemente, no es posible construir o almacenar un objeto infinito en su totalidad.
Sin embargo, gracias a la evaluacin pereosa se puede construir objetos infinitos piea
a piea segn las necesidades de evaluacin.
7/25/2019 Terico Unidad 6
17/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 16
2.EL LENGAJE HASKELL
2.1 INRODCCIN
Haskell es un lenguaje funcional puro, de propsito general, que incluye muchas de las ltimas
innovaciones en el desarrollo de los lenguajes de programacin funcional, como son las funciones de
orden superior, evaluacin pereosa (lay evaluation), tipado polimrficos, tipos definidos por el
usuario, entre otras.
Su nombre proviene de Haskell Brooks Curry, quien trabaj en la lgica matemtica que sirve como
fundamento de los lenguajes funcionales. Haskell se basa en el clculo lambda, ran por la cual el signo
de lambda () es utiliado como cono.
Est especficamente diseado para manejar un ancho rango de aplicaciones, tanto numricas como
simblicas. Para este fin, Haskell tiene una sintaxis expresiva y una gran variedad de constructores de
tipos, a parte de los tipos convencionales (enteros, punto flotante y booleanos).
Hay disponible un gran nmero de implementaciones. Todas son gratis. Los primeros usuarios, tal ve,
deban empear con Hugs, un intrprete pequeo y portable de Haskell.
2.1.1 POR QE SAR HASKELL?
Escribir en grandes sistemas software para trabajar es difcil y caro. El mantenimiento de estos sistemases an ms caro y difcil. Los lenguajes funcionales, como Haskell pueden hacer esto de manera ms
barata y ms fcil.
Haskell, un lenguaje puramente funcional ofrece:
1. Un incremento substancial de la productividad de los programas.
2. Cdigo ms claro y ms corto
3. Una semntica de huecos ms pequea entre el programador y el lenguaje.
4. Tiempos de computacin ms cortos.
Haskell es un lenguaje de amplio espectro, apropiado para una gran variedad de aplicaciones. Es
particularmente apropiado para programas que necesitan ser altamente modificados y mantenidos.
La vida de muchos productos software se basa en la especificacin, el diseo y el mantenimiento y no en
la programacin.
7/25/2019 Terico Unidad 6
18/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 17
2.1.2 HASKELL EN ACCIN
Haskell es un lenguaje de programacin fuertemente tipado (en trminos anglfilos, a typeful
programming language; trmino atribuido a Luca Cardelli). Para aquellos lectores que estn
familiariados con Java, C, Modula, o incluso ML, el acomodo a este lenguaje ser ms significativo,
puesto que el sistema de tipos de Haskell es diferente y algo ms rico.
2.2 IPOS DE DAOS
Una parte importante del lenguaje Haskell lo forma el sistema de tipos que es utiliado para detectar
errores en expresiones y definiciones de funcin.
El universo de valores es particionado en colecciones organiadas, denominadas tipos. Cada tipo tiene
asociadas un conjunto de operaciones que no tienen significado para otros tipos, por ejemplo, se puede
aplicar la funcin (+) entre enteros pero no entre caracteres o funciones.
Una propiedad importante del Haskell es que es posible asociar un nico tipo a toda expresin bien
formada. Esta propiedad hace que el Haskell sea un lenguaje fuertemente tipado. Como consecuencia,
cualquier expresin a la que no se le pueda asociar un tipo es rechaada como incorrecta antes de la
evaluacin. Por ejemplo:
f x = 'A'
g x = x + f x
La expresin 'A' denota el caracter A. Para cualquier valor de x, el valor de f x es igual al caracter 'A', por
tanto es de tipo Char. Puesto que el (+) es la operacin suma entre nmeros, la parte derecha de la
definicin de g no est bien formada, ya que no es posible aplicar (+) sobre un caracter.
El anlisis de los escritos puede dividirse en dos fases: Anlisis sintctico, para chequear la correccin
sintctica de las expresiones y anlisis de tipo, para chequear que todas las expresiones tienen un tipo
correcto.
2.2.1 SISEMA DE INFERENCIA DE IPOS
Haskell cuenta con un sistema de inferencia de tipos que consiste en:
El programador no est obligado a declarar explcitamente el tipo de las expresiones, sin
embargo es aconsejable y una buena practica escribirlas.
Si el programador declara el tipo de alguna expresin, el sistema chequea que el tipo
declarado coincida con el tipo inferido.
7/25/2019 Terico Unidad 6
19/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 18
Los sistemas de inferencia de tipos permiten una mayor seguridad evitando errores de tipo en
tiempo de ejecucin y una mayor eficiencia, y de esta manera se evita tener que realiar
comprobaciones de tipos en tiempo de ejecucin. Por ejemplo, si el programador declara la siguiente
funcin:
eligeSaludo x = if x then "adios" else "hola"
El sistema infiere automticamente que el tipo es eligeSaludo::Bool > String y, si el
Programador hubiese declarado que tiene un tipo diferente, el sistema dara un error de tipos.
Los sistemas de inferencia de tipos aumentan su flexibilidad mediante la utiliacin del
polimorfismo.
Otro ejemplo:
Dada la expresin:
doble x = 2 * x
donde 2 * x implica que el operador (*) se debe poder aplicar sobre 2 y sobre x. Luego, si x
fuera de tipo String, el compilador nos informara un error de tipos.
Haskell nos infomar sobre un conflicto de tipos en las siguientes situaciones:
1) Si se define la funcin: doble x = nombre * x . Entonces el valor nombre no es del tipo
adecuado para el operador (*).
2) Si se define la funcin:
doble :: String > Int
doble x = 2 * x
Entonces tendremos un error al intentar la operacin (*) con un argumento de tipo String.
3) Al evaluar la expresin Main> doble 2, el valor 2 (String) no coincide con el tipo Int.
Aunque no es obligatorio incluir la informacin de tipo, s es considerado una buena prctica, ya que
Haskell chequea que el tipo declarado coincida que el tipo inferido por el sistema a partir de la
definicin, permitiendo as detectar errores de tipos.
2.2.2 IPOS PREDEFINIDOS
Existen varios tipos predefinidos del sistema Haskell, stos se podran clasificar en: ,
cuyos valores se toman como primitivos, por ejemplo, Enteros, Flotantes, Caracterses y Booleanos; y
, cuyos valores se construyen utiliando otros tipos, por ejemplo, listas, funciones y
tuplas.
7/25/2019 Terico Unidad 6
20/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 19
Describiremos a continuacin los tipos bsicos:
B
Se representan por el tipo "Bool" y contienen dos valores: "True" y "False". Las funciones para
manipular valores boleanos son: (&&), () y not.
x && y es True si y slo si x e y son True
x y es True si y slo si x y ambos son True
not x es el valor opuesto de x (not True = False,not False = True)
E
Representados por el tipo "Int", se incluyen los enteros positivos y negativos tales como el 273,el 0 el 383. Como en muchos sistemas, el rango de los enteros est restringido. Tambin se puede
utiliar el tipo Integer para denotar enteros sin lmites superior ni inferior.
A continuacin proveemos algunos operadores y funciones que permiten manipular enteros:
(+) suma.(*) multiplicacin.() substraccin.(^) potenciacin.negate menos unario (la expresin "x" se toma como "negate x")div divisin entera " "rem resto de la divisin entera. Siguiendo la ley: (x `div` y)*y + (x rem` y) == x
mod mdulo, como rem slo que el resultado tiene el mismo signo que el divisor.odd devuelve True si el argumento es impareven devuelve True si el argumento es par.gcd mximo comn divisor.lcm mnimo comn mltiplo.abs valor absolutosignum devuelve 1, 0 o 1 si el argumento es negativo, cero positivo, respectivamente.
Ejemplos:
3^4 == 81, 7 `div` 3 == 2, even 23 == False
7 `rem` 3 == 1, -7 `rem` 3 == -1, 7 `rem` -3 == 1
7 `mod` 3 == 1, -7 `mod` 3 == 2, 7 `mod` -3 == -2gcd 32 12 == 4, abs (-2) == 2, signum 12 == 1
F
Representados por el tipo "Float", los elementos de este tipo pueden ser utiliados para
representar fraccionarios as como cantidades muy largas o muy pequeas. Sin embargo, tales valores
son slo aproximaciones a un nmero fijo de dgitos y pueden aparecer errores de redondeo en algunos
7/25/2019 Terico Unidad 6
21/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 20
clculos que empleen operaciones en punto flotante. Un valor numrico se toma como un flotante
cuando incluye un punto en su representacin o cuando es demasiado grande para ser representado
por un entero. Tambin se puede utiliar notacin cientfica; por ejemplo 1.0e3 equivale a 1000.0,
mientras que 5.0e2 equivale a 0.05.
Algunos operadores y funciones de manipulacin de flotantes:
(+), (), (*), (/) Suma, resta, multiplicacin y divisin fraccionaria.
(^) Exponenciacin con exponente entero.
(**) Exponenciacin con exponente fraccionario.
sin, cos, tan Seno, coseno y tangente.
asin, acos, atan Arcoseno, arcocoseno y arcotangente.
truncate Convierte un nmero fraccionario en un entero redondeando hacia el cero
(trunca la parte decimal).
round Convierte un nmero fraccionario en un entero redondeando hacia el entero
ms cercano.
fromIntegral Convierte un entero en un nmero en punto flotante.
log Logaritmo en base e.
sqrt Ra cuadrada (positiva).
C
Representados por el tipo "Char", los elementos de este tipo representan caracteres
individuales como los que se pueden introducir por teclado. Los valores de tipo caracter se escriben
encerrando el valor entre comillas simples, por ejemplo 'a', '0', '.' y 'Z'. Algunos caracteres especialesdeben ser introducidos utiliando un cdigo de escape; cada uno de stos comiena con el caracter de
barra invertida (\), seguido de uno o ms caracteres que seleccionan el caracter requerido. Algunos de
los ms comunes cdigos de escape son:
'\\' barra invertida'\'' comilla simple'\"' comilla doble'\n' salto de lnea'\t' or '\HT' tabulador
2.3 FNCIONES
Las funciones en Haskell son objetos de primera clase. Pueden ser argumentos o resultados de otras
funciones o ser componentes de estructuras de datos. Esto permite simular mediante funciones de un
nico argumento, funciones con mltiples argumentos.
Si a y b son dos tipos, entonces a->b es el tipo de una funcin que toma como argumento un
elemento de tipo a y devuelve un valor de tipo b.
7/25/2019 Terico Unidad 6
22/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 21
Considrese, por ejemplo, la funcin de suma (+). En matemticas se toma la suma como una funcin
que toma una pareja de enteros y devuelve un entero. Sin embargo, en Haskell, la funcin suma tiene el
tipo:
(+)::Int->(Int->Int)
(+) es una funcin de un argumento de tipo Int que devuelve una funcin de tipo Int->Int. De
hecho "(+) 5" denota una funcin que toma un entero y devuelve dicho entero ms 5. Este proceso
se denomina (en honor a Haskell B.Curry ) y permite reducir el nmero de parntesis
necesarios para escribir expresiones. De hecho, no es necesario escribir f(x) para denotar la
aplicacin del argumento x a la funcin x, sino simplemente f x.
Nota : Se podra escribir simplemente (+)::Int->Int->Int, puesto que el operador -> es
asociativo a la derecha.
En Haskell las funciones se definen usualmente a travs de una coleccin de ecuaciones. Por ejemplo, la
funcin inc puede definirse por una nica ecuacin:
inc n = n+1
Una ecuacin es un ejemplo de declaracin. Otra forma de declaracin es la declaracin de tipo de una
funcin o type signature declaration, con la cual podemos dar de forma explcita el tipo de una funcin;
por ejemplo, el tipo de la funcin inc:
inc :: Integer -> Integer
A continuacin proveemos de otro ejemplo con dos maneras alternativas de definir la funcin suma:
suma::Integer -> Integer -> Integer
suma x y = x + y
Entonces, la invocacin a esta funcin se har de la siguiente forma:
suma 2 5
7
,
()
suma::(Integer, Integer) -> Integer
suma (x, y) = x + y
Luego, la invocacin a esta funcin se debe hacer de la siguiente manera:
suma (2,5)
7
N : I
7/25/2019 Terico Unidad 6
23/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 22
Existen dos formas de nombrar una funcin, mediante un identificador (por ejemplo, sum,
product y fact) y mediante un smbolo de operador (por ejemplo, * y +). El sistema distingue entre los
dos tipos segn la forma en que estn escritos:
Los operadores se utilian usando por defecto la notacin infija, lo que facilita la lectura
matemtica:
4 + 3
x + y
Sin embargo, tambin es posible usar el operador en notacin prefija como se muestra en el
siguiente ejemplo:
(+) 2 3
2.4 EL ENORNO DE HASKELL HGS
El entorno funciona siguiendo el modelo de una calculadora en el que se establece una sesin
interactiva entre el ordenador y el usuario. Una ve arrancado, el sistema muestra un "?" y
espera a que el usuario introduca una expresin (denominada y presione la tecla
. Cuando la entrada se ha completado, el sistema evala la expresin e imprime su valor
antes de volver a mostrar el para esperar a que se introduca la siguiente expresin.
E:
? (2+3)*8
40
? sum [1..10]
55
En el primer ejemplo, el usuario introdujo la expresin "(2+3)*8" que fue evaluada por el sistema
imprimiendo como resultado el valor "40".
En el segundo ejemplo, el usuario tecle "sum [1..10]". La notacin [1..10] representa la
lista de enteros que van de 1 hasta 10, y sum es una funcin estndar que devuelve la suma de una
lista de enteros. El resultado obtenido por el sistema es:
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55
En los ejemplos anteriores, se utiliaron funciones estndar, incluidas junto a una larga coleccin de
funciones en un fichero denominado " " que es cargado al arrancar el sistema. Con
dichas funciones se pueden realiar una gran cantidad de operaciones tiles. Por otra parte, el usuario
puede definir sus propias funciones y almacenarlas en un fichero de forma que el sistema pueda
7/25/2019 Terico Unidad 6
24/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 23
utiliarlas en el proceso de evaluacin. Por ejemplo, el usuario podra crear un fichero . con el
contenido:
cuadrado::Integer -> Integer
cuadrado x = x * x
menor::(Integer, Integer) -> Integer
menor (x,y) = if x :load fichero.hs
Hugs>:l fichero.hs
Si el fichero se carg con xito, el usuario ya podra utiliar la definicin:
Main> cuadrado 2
4 :: Integer
Main> cuadrado(3+5)
64 :: Integer
Main> menor(2,4)
2 :: Integer
Main> cuadrado (menor (3,4))
9 :: Integer
Es conveniente entre un como ente abstracto y su , un expresin
formada por un conjunto de smbolos. En general a un mismo valor abstracto le pueden corresponder
diferentes representaciones. Por ejemplo, 7+7, cuadrado 7,
49, XLIX (49 en nmeros romanos), 110001 (en binario) representan el mismo valor.
El proceso de consiste en tomar una expresin e ir transformndola aplicando las
definiciones de funciones (introducidas por el programador o predefinidas) hasta que no pueda
transformarse ms. La expresin resultante se denomina representacin cannica y es mostrada al
usuario.
Existen valores que no tienen representacin cannica (por ejemplo, las funciones) o que tienen una
representacin cannica infinita (por ejemplo, el nmero pi).
Por el contrario, otras expresiones, no representan ningn valor. Por ejemplo, la expresin (1/0) o la
expresin (infinito). Se dice que estas expresiones representan el valor indefinido.
En resumen, para escribir un programa en Haskell hay que cumplir los siguientes pasos:
7/25/2019 Terico Unidad 6
25/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 24
1. Escribir un script con la definicin de todas las funciones que necesitemos para resolver el
problema. Se puede utiliar cualquier editor de texto, aunque es recomendable usar alguno
que resalte automticamente la sintaxis de Haskell. Guardamos el archivo con una extensin
.hs.
2. Cargar el script en Hugs. Para ello utiliamos el comando: load seguido del nombre del archivo.
Ahora en el prompt de Hugs ya podemos evaluar cualquier expresin que haga referencia a
funciones definidas en el script.
3. Ingresar en el prompt la expresin a evaluar y presionar la tecla , para que el sistema
evale la expresin e imprima su valor antes de volver a mostrar el.
2.4.1 ELEMENOS DE HGS
P.
El prelude es un fichero de nombre Prelude.hs que es cargado automticamente al arrancar Hugs y
contiene la definicin de un conjunto de funciones que podemos usar cuando las necesitemos.
Algunos ejemplos: div, mod, sqrt, id, fst, snd.
Al iniciar una sesin en Hugs, nos aparecer una ventana como sta:
Hugs evaluar cualquier expresin, sintcticamente correcta, que se ingrese en el prompt
Hugs>
Por ejemplo, si ingresemos (7 + 4) 3, la evaluar y nos devolver 33
Hugs> (7+4)*3
7/25/2019 Terico Unidad 6
26/48
Universidad TecnolgicFacultad Regional CrdDpto de Ingeniera en SCtedra de Paradigmas
33 :: Integer
Si ingresamos sqrt 2, nos devolver
Hugs> sqrt 2
1.4142135623731 ::
2.4.2 COMANDOS DE HGS
Si uno escribe :? y presiona ENTER:
La primera lnea dice que se puede
C
Para cargar un archivo hay que utili
Hugs> :l nuevo.hs
E
Para editar un archivo, hay que utiliEjemplo 1:
--edit
Hugs>
Ejemplo 2:
a Nacionalobaistemas de Informacinde Programacin
una aproximacin de2
Double
usar como abreviatura slo la primera letra de cada com
ar el comando :load .
ar el comando :edit.
el ltimo archivo cargado
:edit
ando.
7/25/2019 Terico Unidad 6
27/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 26
--edita el archivo especificado
Hugs> :edit archivo.hs
C
Para crear un nuevo archivo hay que usar el comando :edit , el sistema intentar abrirlo, al noencontrarlo informar que no existe y preguntar si quiere crear uno nuevo, si se acepta la edicin y secomiena a escribir el nuevo cdigo.
Hugs> :e nuevo.hs
2.4.3 MDLOS
Haskell proporciona un conjunto de definiciones globales que pueden ser usadas por el programador sin
necesidad de definirlas. Estas definiciones aparecen agrupadas en mdulos de biblioteca. Una bibliotecaes un conjunto de definiciones relacionadas.
La importacin de los mdulos se consigue escribiendo la palabra import al inicio del programa.
En Hugs existen libreras llenas de mdulos muy tiles, por ejemplo, el mdulo de biblioteca Prelude,
visto anteriormente, es automticamente importado por cualquier programa.
Cada programa o script que se crea va a ser un mdulo, y un conjunto de mdulos formarn un
proyecto.
Una ve que se comiena a escribir un script es recomendable definir el nombre de ese mdulo.
Supongamos que vas a crear un programa que quieras llamarTest1, debes hacer lo siguiente (en tu editor de
texto):
Definir el mdulo de la siguiente forma:
module Test1 where
Donde la primera letra del nombre del mdulo debe ir en maysculas.
Escribir el programa, grabar y cargarlo en Hugs y ahora en ve de aparecer
Hugs>
Aparecer esto:
Test1>
La ventaja de los mdulos es que pueden importarse, y cargar muchos programas a la ve, usando el
comando import.
Ejemplo de Hola Mundo:
--MiPrimerPrograma.hs
module Main where
7/25/2019 Terico Unidad 6
28/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 27
main = putStrLn "Hola mundo!"
Si lo evaluamos:
Main> main
Hola mundo!
:: IO ()
2.5 SINAIS DE HASKELL
En esta seccin se muestra lo esencial de la sintaxis de Haskell.
2.5.1 CASE SENSIIE
La sintaxis de Haskell diferencia entre maysculas y minsculas. Se dice que es Case sensitive.
2.5.2 COMENARIOS
Una buena prctica de programacin es documentar siempre el cdigo fuente. Un comentario en
un script es informacin de valor para el lector humano, ms que para el computador (no interviene
para nada al momento de evaluar una expresin). Hay dos formas de expresar los comentarios:
En una lnea: utilia el smbolo que inicia un comentario y ocupa la parte de la lnea hacia la
derecha del smbolo. Por ejemplo:
-- Este es un comentario, cuando empieza con "--
MultiLinea: utilia para inicia el comentario y para finaliarlo. Por ejemplo:
{- Este es un comentario,
en dos lneas-}
2.5.3 ALORES
Los valores son entidades abstractas que podemos considerar como la respuesta a un clculo
5 -1 8
Cada valor tiene asociado un tipo ( :: )
2 :: Int
Int {...-3,-2,-1,0,1,2,3...}
7/25/2019 Terico Unidad 6
29/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 28
2.5.4 EPRESIONES
Las expresiones son trminos construidos a partir de valores
(2*3)+(4-5)
La reduccin o evaluacin de una expresin consiste en aplicar una serie de reglas que transforman la
expresin en un valor
(2*3)+(4-5) 6+(4-5) 6+(-1) 6-1 5
Un valor es una expresin irreducible
Toda expresin tiene un tipo: el tipo del valor que resulta de reducir la expresin (Sistema Fuertemente
Tipado).
(2*3)+(4-5) :: Int
Las funciones tambin son valores (y por lo tanto tendrn tipo)
2.5.5 IDENIFICADORES
Un identificador Haskell consta de una letra seguida por cero o ms letras, dgitos, subrayados y comillas
simples. Los identificadores son (el uso de minsculas o maysculas importa).
Los siguientes son ejemplos posibles de identificadores:
sum f f fintSum nombre_con_guiones
Los siguientes identificadores son palabras reservadas y no pueden utiliarse como nombres de
funciones o variables:
case of where let in if then else data type infix
infixl infixr class instance primitive
La letra inicial del identificador distingue familias de identificadores: empiean por
los tipos y constructores de datos
los nombres de funcin y variables
2.5.6 OPERADORES
En Haskell los operadores son funciones que se escriben entre sus (dos) argumentos en lugar de
precederlos. A una funcin escrita usando la notacin infija se le llama un operador. Por ejemplo,
7/25/2019 Terico Unidad 6
30/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 29
3 ? @ \ ^
Cuando se trabajan con smbolos de operador es necesario tener en cuenta:
L :La expresin "2 * 3 + 4" podra interpretarse como "(2 * 3) + 4"o como "2 * (3 +
4)". Para resolver la ambigedad, cada operador tiene asignado un valor de precedencia (un
entero entre 0 y 9). En una situacin como la anterior, se comparan los valores de precedencia
y se utilia primero el operador con mayor precedencia (en el standar prelude el (+) y el (*)
tienen asignados 6 y 7, respectivamente, por lo cual se realiara primero la multiplicacin).
L : La regla anterior resolva ambigedades cuando los smbolos de operador
tienen distintos valores de precedencia, sin embargo, la expresin "1 2 3" puede ser tratada
como "(1 2) 3" resultando 4 o como "1 (2 3)" resultando 2. Para resolverlo, a cada
operador se le puede definir una regla de asociatividad. Por ejemplo, el smbolo () se puede
decir que es:
Asociativo a la iquierda: si la expresin "xy" se toma como "(xy)"
Asociativo a la derecha: si la expresin "xy" se toma como "x(y)"
No asociativo: Si la expresin "xy" se rechaa como un error sintctico.
En el standar prelude, el () se toma como asociativo a la iquierda, por lo que la expresin "1 2 3" se
tratar como "(12)3".
Por defecto, todo smbolo de operador se toma como noasociativo y con precedencia 9.
2.5.7 EPRESIONES IFHENELSE
En Haskell, no hay estructuras de control, pero si existe la funcin especial if then else, que implica
otro modo de escribir expresiones cuyo resultado depende de cierta condicin, la sintaxis es:
if exprBool then exprSi else exprNo
Si la expresin booleanaexprBooles True devuelve exprSi, si es False, devuelve exprNo.
Obsrvese que una expresin de ese tipo slo es aceptable si exprBooles de tipo Bool y exprSiy
exprNoson del mismo tipo.
Por ejemplo:
Hugs> if 5 > 2 then 10.0 else 20.0
10.0 :: Double
Hugs> 2 if a
7/25/2019 Terico Unidad 6
31/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 30
Ejemplos, definiendo funciones:
El mayor de dos nmeros:
maxEnt:: Integer -> Integer -> Integer
maxEnt x y = if x >= y then x else y
La evaluacin sera:
Main> maxEnt 3 7
7 :: Integer
El mayor de tres nmeros:
mayor:: Int->Int->Int->Int
mayor x y z = if x >= y && x>=z then x
else if y >= x && y>=z then yelse z
La evaluacin sera:
Main> mayor 2 3 4
4 :: Int
2.5.8 EPRESIONES CASE
Una expresin case puede ser utiliada para evaluar una expresin y, dependiendo del resultado,
devolver uno de los posibles valores.
paridad :: Int -> String
paridad x = case (x `mod` 2) of
0 -> "par"
1 -> "impar"
Al evaluar la funcin:
Hugs> paridad 3
"impar" :: [Char]
2.5.9 EPRESIONES CON GARDAS
Cada una de las ecuaciones de una definicin de funcin podra contener que requieren que se
cumplan ciertas condiciones sobre los valores de los argumentos. En general una ecuacin con guardas
toma la forma:
f x1 x2 ... xn | condicion1 = e1
7/25/2019 Terico Unidad 6
32/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 31
| condicion2 = e2
.
.
| condicionm = em
| otherwise = exp
Esta ecuacin se utilia para evaluar cada una de las condiciones por orden hasta que alguna de ellas sea
"True", en cuyo caso, el valor de la funcin vendr dado por la expresin correspondiente en la parte
derecha del signo "=".
En Haskell, "otherwise" evala a "True". Por lo cual, escribir "otherwise" como una
condicin significa que la expresin correspondiente ser siempre utiliada si no se cumpli ninguna
condicin previa.
E
1. minimo x y | x minimo 3 6
3 :: Integer
Main> minimo 7 5
5 :: Integer
2. absoluto:: Integer -> Integer
absoluto x | x >= 0 = x
| x < 0 = -x
Al evaluar la funcin:
Main> absoluto 3
3 :: Integer
Main> absoluto (-4)
4 :: Integer
3. signo :: Integer -> Integer
signo x | x > 0 = 1
| x == 0 = 0
| otherwise = 1
Al evaluar la funcin:
7/25/2019 Terico Unidad 6
33/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 32
Main> signo 3
1 :: Integer
Main> signo 0
0 :: Integer
Main> signo (-10)
-1 :: Integer
2.5.10 DEFINICIONES LOCALES
Las definiciones de funciones pueden incluir definiciones locales para variables que pueden ser usadas
en guardas o en la parte derecha de una ecuacin, en Haskell hay dos formas:
EXPRESIONES LET .
Las de Haskell son tiles cuando se requiere un conjunto de declaraciones locales. Se
introducen en un punto arbitrario de una expresin utiliando una expresin de la forma:
let in
Por ejemplo:
Hugs> let x = 1 + 4 in x*x + 3*x + 1
41 :: Integer
:
Hugs> let p x = x*x + 3*x + 1 in p (1 + 4)
41 :: Integer
EXPRESIONES WHERE
A veces es conveniente establecer declaraciones locales en una ecuacin con varias con guardas, lo que
podemos obtener a travs de una :
f x y | y>z = ...
| y==z = ...
| y
7/25/2019 Terico Unidad 6
34/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 33
Estas dos formas de declaraciones locales son muy similares, pero recordemos que una expresin let
es una , mientras que una clusula whereno forma parte de la sintaxis de la declaracin de
funciones y de expresiones case.
Por ejemplo:
comparaCuadrado::Integer -> Integer -> String
comparaCuadrado x y | y>z = " el segundo argumento es mayor
que el cuadrado del primero"
| y==z = "el segundo argumento es igual
que el cuadrado del primero"
| y comparaCuadrado 5 3
"el segundo argumento es menor que el cuadrado del primero" ::
[Char]
Main> comparaCuadrado 5 45
" el segundo argumento es mayor que el cuadrado del primero" ::
[Char]
Main> comparaCuadrado 5 25
"el segundo argumento es igual que el cuadrado del primero" ::
[Char]
2.5.11 DISPOSICIN DEL CDIGO:ESPACIADO (LAO)
En Haskell no existe el concepto de separadores que marquen el final de una ecuacin, una declaracin,
etc. Para determinar esto, Haskell, utilia una sintaxis bidimensional denominada () que
se basa esencialmente en que las declaraciones estn alineadas por columnas.
Las reglas del espaciado son bastante intuitivas y podran resumirse en:
1. El siguiente caracter de cualquiera de las palabras clave (where, let, o of) es el que
determina la columna de comieno de declaraciones en las expresiones where, let, o case
correspondientes. Por tanto podemos comenar las declaraciones en la misma lnea que la
palabra clave, en la siguiente o siguientes.
2. Es necesario asegurarse que la columna de comieno dentro de una declaracin est ms a la
derecha que la columna de comieno de la siguiente clusula. En caso contrario, habra
ambigedad, ya que el final de una declaracin ocurre cuando se encuentra algo a la iquierda
de la columna de comieno.
El uso del layout reduce en gran medida el desorden sintctico asociado con los grupos de
declaraciones, mejorando la legibilidad. Es fcil de aprender y recomendamos su uso.
Por ejemplo, dada la siguiente expresin:
7/25/2019 Terico Unidad 6
35/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 34
--usando layout
ejemplo1::Integer
ejemplo1 = (a + a)
where a = 6
ejemplo2::Integer
ejemplo2 = (a + b)
where
a = 6
b = 5
2.5.12 EPRESIONES RECRSIAS
Una expresin es recursiva cuando su evaluacin (en ciertos argumentos) involucra el llamado a la
misma expresin que se esta definiendo. La recursin es una herramienta poderosa y usada muy
frecuentemente en los programas en Haskell.
La recursin es una tcnica que se basa en definir expresiones en trminos de ellas mismas. Si del lado
derecho de una expresin aparece en algn punto la misma expresin que figura del lado iquierdo, se
dice que la expresin tiene llamado recursivo, es decir .
En la definicin recursiva, es necesario considerar dos momentos de evaluacin:
E B: Momento en que se detiene el proceso de evaluacin, se
obtiene una valoriacin de la expresin.
E R: Se evala la expresin actual, efectuando evaluaciones a si
misma, hasta obtener la valoriacin de la expresin.
Por ejemplo, recordemos la definicin (matemtica) de la funcin factorial:
factorial : N N
factorial(0) = 1
factorial(n) = n factorial(n 1)
si n > 0
Podemos definir esta funcin en Haskell con una correspondencia directa:
1. Ejemplo usando una sola expresin, en donde la evaluacin del caso bsico y la evaluacin
recursiva estn en una expresin ifthenelse:
factorial:: Integer -> Integer
factorial n = if n==0 then 1
else n * fact(n-1)
2. Ejemplo usando dos expresiones, una para evaluar el caso bsico y la otra para hacer la
evaluacin recursiva:
factorial::Integer -> Integer
factorial 0 = 1
7/25/2019 Terico Unidad 6
36/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 35
factorial n | n > 0 = n * factorial (n-1)
EPRESIONES
Adems de las definiciones de funcin con nombre, es posible definir y utiliar funciones sin necesidad
de darles un nombre explcitamente mediante expresiones de la forma:
\ ->
Esta expresin denota una funcin que toma un nmero de parmetros (uno por cada patrn)
produciendo el resultado especificado por la expresin . Por ejemplo, la expresin:
(\x->x*x)
representa la funcin que toma un nico argumento entero 'x' y produce el cuadrado de ese nmero
como resultado. Otro ejemplo sera la expresin
(\x y->x+y)
que toma dos argumentos enteros y devuelve su suma. Esa expresin es equivalente al operador (+):
Hugs>(\x y->x+y) 2 3
5
2.6 IPOS DE DAOS COMPESOS
Los tipos compuestos, son aquellos cuyos valores se construyen utiliando otros tipos.
2.6.1 PLAS
Una tupla es un dato compuesto, es una sucesin de elementos, donde el tipo de cada elemento puede
ser distinto. El tamao de una tupla es fijo.
Definicin general: Si T1,T2,...,Tn son tipos y n 2, entonces hay un tipo de ntuplas escrito (T1,T2,...,Tn)
cuyos elementos pueden ser escritos como (x1,x2,...,xn) donde cada x1,x2,...,xn tiene tipos T1,T2,...,Tn.
Aridad:
La aridad de una tupla es el nmero de elementos.
La tupla de aridad 0, (), es la tupla vaca, denominada tipo unidad.
No estn permitidas las tuplas de longitud 1.
Ejemplos:
7/25/2019 Terico Unidad 6
37/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 36
(False,True) :: (Bool,Bool)
(False,'a',True) :: (Bool,Char,Bool)
(1, [2], 3) :: (Int, [Int], Int)
('a', False) :: (Char, Bool)((1,2),(3,4)) :: ((Int, Int), (Int, Int))
Obsrvese que los elementos de una tupla pueden tener tipos diferentes y el tamao de una tupla es
fijo.
Las tuplas son tiles cuando una funcin tiene que devolver ms de un valor, por ejemplo:
--devuelve el anterior y posterior de un nmero
antPos:: Integer -> (Integer,Integer)
antPos x = (x - 1, x + 1)
Main> antPos 2
(1,3) :: (Integer,Integer)
2.6.2 LISAS
Una lista es una coleccin de cero o ms elementos todos del mismo tipo. Las expresiones de tipo lista
se construyen con [] (que representa la lista vaca) y : (a:as es la lista que empiea con el elemento a y
sigue con la lista as). Tambin pueden escribirse entre corchetes, con los elementos separados por
comas.
Sintaxis para listas
x1: (x2: (...(xn1: (xn: [])))) [x1,x2,...xn1,xn]
Ejemplo:
1:(2:(3:([]))) [1,2,3]
Si el tipo de todos los elementos de una lista es t, entonces el tipo de la lista se escribe [t]:
D : Si v1,v2,...,vn son valores con tipo t, entonces v1: (v2: (...(vn1: (vn: [])))) es una lista
con tipo [t].
Por ejemplo: [Int] representa el tipo lista de enteros, [Bool] es una lista de booleanos, etc.
D : Una lista est compuesta por una cabea y una cola que es una lista compuesta
por los elementos restantes.
La lista que no tiene elementos no puede dividirse en cabea y cola. Se denota [ ] y se dice lista vaca.
7/25/2019 Terico Unidad 6
38/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 37
En una lista el operador (:) permite dividir cabea y cola: (x:xs)
Longitudes:
La longitud de una lista es el nmero de elementos.
La lista de longitud 0, [], es la lista vaca.
Las listas de longitud 1 se llaman listas unitarias.
Ejemplos
[False,True] :: [Bool] --contiene elementos booleanos
[1,2,3]:: [Int] --contiene elementos enteros
['a', 'a', 'a'] :: [Char] --contiene elementos char,
--se visualiza como un String "aaa"
[(True,1), (False,2)]:: [(Bool,Int)] --contiene
tuplas(Bool,Int)
[[1,2,3], [4], [5,6]]:: [[Int]] --contiene listas de enteros["uno","dos"] :: [[Char]] --contiene elementos listas de char
-- o String
El tipo String es sinnimo de [Char], y las listas de este tipo se pueden escribir entre comillas:
"uno" es lo mismo que [u, n, o].
A
length xs devuelve el nmero de elementos de xs
xs ++ ys devuelve la lista resultante de concatenar xs e ys
concat xss devuelve la lista resultante de concatenar las listas de xss
map f xs devuelve la lista de valores obtenidos al aplicar la funcin a cada
uno de los elementos de la lista xs.
take n xs devuelve los n primeros elementos de xs
drop n xs devuelve el resultado de sacarle a xs los primeros n elementos
head xs devuelve el primer elemento de la lista
tail xs devuelve toda la lista menos el primer elemento
last xs devuelve el ltimo elemento de la lista
init xs devuelve toda la lista menos el ltimo elemento
xs ++ys concatena ambas listas
xs !! n devuelve el nsimo elemento de xs
elem x xs dice si x es un elemento de xs
Ejemplos:
Hugs>length [1,3,10]
3
Hugs>[1,3,10] ++ [2,6,5,7]
7/25/2019 Terico Unidad 6
39/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 38
[1, 3, 10, 2, 6, 5, 7]
Hugs>concat [[1], [2,3], [], [4,5,6]]
[1, 2, 3, 4, 5, 6]
Hugs>map fromEnum ['H', 'o', 'l', 'a']
[104, 111, 108, 97]
Ejemplos usando funciones propias:
1. Retorna una lista de enteros:
lista:: [Int]
lista = [1,2,3]
Main> lista[1,2,3] :: [Int]
2. Dada una lista de enteros retornar la suma de todos los elementos:
sumar:: [Integer] -> Integer
sumar []= 0
sumar (x : xs) = x + sumar xs
Main> sumar [1,2,3]
6 :: Integer
3. Dada una lista de enteros retornar la cantidad de elementos:
contar:: [Integer] -> Integer
contar []= 0
contar (x : xs) = 1 + contar xs
Main> contar [1,2,3]
3 :: Integer
4. Dada una lista de enteros mostrar sus elementos:
mostrar:: [Int] -> String
mostrar [] = []
mostrar (x : xs) = show(x) ++ " " ++ mostrar xs
Main> mostrar [1,1,1]
"111" :: [Char]
7/25/2019 Terico Unidad 6
40/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 39
2.7 IPOS DEFINIDOS POR EL SARIO
2.7.1 SINNIMOS DE IPO
Los sinnimos de tipo se utilian para proporcionar abreviaciones para expresiones de tipo aumentando
la legibilidad de los programas. Un sinnimo de tipo es introducido con una declaracin de la forma:
type Nombre a1 ... an = expresion_Tipo
donde
Nombre es el nombre de un nuevo constructor de tipo de aridad n>=0
a1,..., an son variables de tipo diferentes que representan los argumentos de
Nombre
expresion_Tipo es una expresin de tipo que slo utilia como variables de tipo las
variables a1,..., an.
Ejemplos:
type Nombre = String
type Edad = Integer
type String = [Char]
type Persona = (Nombre, Edad)
tocayos::Persona -> Persona -> Bool
tocayos (nombre,_) (nombre',_) = n == nombre'
El tipo String es un sinnimo de tipo, posee la siguiente defincin:
type String = [Char]
Sintaxis especial para las cadenas de caracteres:
[h, o, l, a] "hola"
Ejemplos:
"hola "++ [m, u, n, d, o] => "hola mundo"
2.7.2 DEFINICIONES DE IPOS DE DAOS
Aparte del amplio rango de tipos predefinidos, en Haskell tambin se permite definir nuevos tipos de
datos mediante la sentencia data. La definicin de nuevos tipos de datos aumenta la seguridad de los
7/25/2019 Terico Unidad 6
41/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 40
programas ya que el sistema de inferencia de tipos distingue entre los tipos definidos por el usuario y los
tipos predefinidos.
TIPOS PRODUCTO
Se utilian para construir un nuevo tipo de datos formado a partir de otros.
Ejemplo:
data Persona = Pers Nombre Edad
juan::Persona
juan = Pers "Juan Lopez" 23
Se pueden definir funciones que manejen dichos tipos de datos:
esJoven:: Persona -> Bool
esJoven (Pers _ edad) = edad < 25
verPersona::Persona -> String
verPersona (Pers nombre edad) = "Persona, nombre " ++ nombre ++
", edad: " ++ show edad
Tambin se pueden dar nombres a los campos de un tipo de datos producto:
data = Datos { nombre::Nombre, dni::Integer, edad:Edad }
Los nombres de dichos campos sirven como funciones selectoras del valor correspondiente.
Por ejemplo:
tocayos:: Persona -> Persona -> Bool
tocayos p p' = nombre p == nombre p'
Obsrvese la diferencia de las tres definiciones de Persona
:
type Persona = (Nombre, Edad)
No es un nuevo tipo de datos. En realidad, si se define
type Direccion = (Nombre, Numero)
type Numero = Integer
El sistema no dara error al aplicar una funcin que requiera un valor de tipo persona con un valor de
tipo Direccin. La nica ventaja (discutible) de la utiliacin de sinnimos de tipos de datos podra ser
una mayor eficiencia (la definicin de un nuevo tipo de datos puede requerir un mayor consumo de
recursos.
7/25/2019 Terico Unidad 6
42/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 41
data Persona = Pers Nombre Edad
El valor de tipo Persona es un nuevo tipo de datos y, si se define:
type Direccion = Dir Nombre Numero
El sistema dara error al utiliar una direccin en lugar de una persona.
Si se desea ampliar el valor persona aadiendo, por ejemplo, el "dni", todas las definiciones que
trabajen con datos de tipo Persona deberan modificarse.
data Persona = Pers { nombre::Nombre, edad::Edad }
El campo s es un nuevo tipo de datos y ahora no es necesario modificar las funciones que trabajen con
personas si se amplan los campos.
2.8 IPOS POLIMRFICOS
Haskell proporciona tipos (tipos cuantificados universalmente sobre todos los tipos). Tales
tipos describen esencialmente familias de tipos.
Por ejemplo, (para_todo a)[a]es la familia de las listas de tipo base a, para cualquier tipo a. Las listas de
enteros (e.g. [1,2,3]), de caracteres (['a','b','c']), e incluso las listas de listas de interos, etc., son miembros
de esta familia. (Ntese que [2,'b']es un ejemplo vlido, puesto que no existe un tipo que contenga
tanto a 2como a 'b'.)
Ya que Haskell solo permite el cuantificador universal, no es necesario escribir el smbolo
correspondiente a la cuantificacin universal, y simplemente escribimos [a] como en el ejemplo
anterior. En otras palabras, todas las variables de tipos son cuantificadas universalmente de forma
implcita. Las listas constituyen una estructura de datos comunmente utiliada en lenguajes funcionales,
y constituyen una buena herramienta para mostrar los principios del polimorfismo.
En Haskell, la lista [1,2,3]es realmente una abreviatura de la lista 1:(2:(3:[])), donde []denota la lista
vaca y :es el operador infijo que aade su primer argumento en la cabea del segundo argumento (una
lista). (:y []son, respectivamente, cons nil ) Ya que :es asociativo a la
derecha, tambin podemos escribir simplemente 1:2:3:[].
Ejemplo : el problema de contar el nmero de elementos de una lista
length :: [a] -> Integer
length [] = 0
length (x:xs) = 1 + length xs
Esta definicin es autoexplicativa. Podemos leer las ecuaciones como sigue: "La longitud de la lista vaca
es 0, y la longitud de una lista cuyo primer elemento es x y su resto es xs viene dada por 1 ms la
longitud de xs." (Ntese el convenio en el nombrado: xses el plural de x, y x:xs debe leerse: "una x
seguida de varias x).
7/25/2019 Terico Unidad 6
43/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 42
2.9 IPOS RECRSIOS
Los tipos de datos pueden autorreferenciarse consiguiendo valores recursivos, por ejemplo:
data Expr = Lit Integer
| Suma Expr Expr
| Resta Expr Expr
eval (Lit n) = n
eval (Suma e1 e2) = eval e1 + eval e2
eval (Resta e1 e2) = eval e1 * eval e2
Tambin pueden definirse tipos de datos polimrficos. El siguiente ejemplo define un tipo que
representa rboles binarios:
data Arbol a = Hoja a | Rama (Arbol a) (Arbol a)
Por ejemplo,
a1 = Rama (Rama (Hoja 12) (Rama (Hoja 23) (Hoja 13)) (Hoja 10)
tiene tipo Arbol Integer y representa el rbol binario de la figura :
Otro ejemplo, sera un rbol, cuyas hojas fuesen listas de enteros o incluso rboles.
a2 ::Arbol [Integer]
a2 = Rama (Hoja [1,2,3] Hoja [4,5,6])
a3 :: Arbol (Arbol Int)
a3 = Rama (Hoja a1) (Hoja a1)
A continuacin se muestra una funcin que calcula la lista de nodos hoja de un rbol binario:
hojas :: Arbol a -> [a]
hojas (Hoja h) = [h]
hojas (Rama izq der) = hojas izq ++ hojas der
Utiliando el rbol binario anterior como ejemplo:
? hojas a1
Hugs> hojas a1
[12, 23, 13, 10]
7/25/2019 Terico Unidad 6
44/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 43
? hojas a2
Hugs> hojas a2
[[1,2,3], [4,5,6]]
10
12
23 13
2.10 SOBRECARGA CLASES EN HASKELL
Cuando una funcin puede utiliarse con diferentes tipos de argumentos se dice que est sobrecargada.
La funcin (+), por ejemplo, puede utiliarse para sumar enteros o para sumar flotantes. La resolucin
de la sobrecarga por parte del sistema Haskell se basa en organiar los diferentes tipos en lo que se
denominan
Considrese el operador de comparacin (==). Existen muchos tipos cuyos elementos pueden ser
comparables, sin embargo, los elementos de otros tipos podran no ser comparables. Por ejemplo,
comparar la igualdad de dos funciones es una tarea computacionalmente intratable, mientras que a
menudo se desea comparar si dos listas son iguales. De esa forma, si se toma la definicin de la funcin
elem que chequea si un elemento pertenece a una lista:
x `elem` [] = False
x `elem` (y:ys) = x == y || (x `elem` ys)
Intuitivamente el tipo de la funcin elem debera ser a->[a]->Bool. Pero esto implicara que la
funcin == tuviese tipo a->a->Bool. Sin embargo, como ya se ha indicado, interesara restringir la
aplicacin de == a los tipos cuyos elementos son .
Adems, aunque == estuviese definida sobre todos los tipos, no sera lo mismo comparar la igualdad
de dos listas que la de dos enteros.
Las solucionan ese problema permitiendo declarar qu tipos son instancias de unas
clases determinadas y proporcionando definiciones de ciertas operaciones asociadas con cada clase de
tipos. Por ejemplo, la clase de tipo que contiene el operador de igualdad se define en el
como:
class Eq a where
(==) :: a -> a -> Bool
x == y = not (x /= y)
Eq es el nombre de la clase que se est definiendo, (==) y (/=) son dos operaciones simples sobre
esa clase. La declaracin anterior podra leerse como:
" a Eq (==) ".
La restriccin de que un tipo a debe ser una instancia de una clase Eq se escribe Eq a.
7/25/2019 Terico Unidad 6
45/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 44
Obsrvese que Eq a no es una expresin de tipo sino una restriccin sobre el tipo de un objeto a (se
denomina un ). Los contextos son insertados al principio de las expresiones de tipo. Por
ejemplo, la operacin == sera del tipo:
(==):: (Eq a) => a -> a -> Bool
Esa expresin podra leerse como: " a
clase Eq, == tiene el tipo a->a->Bool".
La restriccin se propagara a la definicin de elem que tendra el tipo:
elem:: (Eq a) => a -> [a] -> Bool
Las declaraciones de instancias permitirn declarar qu tipos son instancias de una determinada clase.
Por ejemplo:
instance Eq Int where
x == y = intEq x y
La definicin de == se denomina . IntEq es una funcin primitiva que compara si dos enteros
son iguales, aunque podra haberse incluido cualquier otra expresin que definiese la igualdad entre
enteros. La declaracin se leera como:
" Int Eq ==
...".
De la misma forma se podran crear otras instancias:
instance Eq Float where
x == y = FloatEq x y
La declaracin anterior utilia otra funcin primitiva que compara flotantes para indicar cmo comparar
elementos de tipo Float. Adems, se podran declarar instancias de la clase Eq tipos definidos por
el usuario. Por ejemplo, la igualdad entre elementos del tipo Arbol definido anteriomente :
instance (Eq a) => Eq (Arbol a) where
Hoja a == Hoja b = a == b
Rama i1 d1 == Rama i2 d2 = (i1==i2) && (d1==d2)
_ == _ = False
Obsrvese que el contexto (Eq a) de la primera lnea es necesario debido a que los elementos de lashojas son comparados en la segunda lnea. La restriccin adicional est indicando que slo se podr
comparar si dos rboles son iguales cuando se puede comparar si sus hojas son iguales.
El incluye un amplio conjunto de clases de tipos. De hecho, la clase Eq est definida
con una definicin ligeramente ms larga que la anterior.
class Eq a where
(==), (/=) :: a->a->Bool
7/25/2019 Terico Unidad 6
46/48
Universidad Tecnolgica NacionalFacultad Regional CrdobaDpto de Ingeniera en Sistemas de InformacinCtedra de Paradigmas de Programacin
Unidad N 5: P F Pgina 45
x /= y = not (x == y)
Se incluyen dos operaciones, una para igualdad (==) y otra para no igualdad (/=). Se puede observar
la utiliacin de un para la operacin (/=). Si se omite la declaracin de un
mtodo en una instancia entonces se utilia la declaracin del mtodo por defecto de su clase. Porejemplo, las tres instancias anteriores podran utiliar la operacin (/=) sin problemas utiliando el
mtodo por defecto (la negacin de la igualdad).
tambin permite la de clases. Por ejemplo, podra ser interesante definir una clase Ord
que todas las oper
Top Related