Unidad 3: Evaluacin perezosa

0






Alumno: Encarnacin Cituk Caamal
Instituto Tecnolgico Superior de Felipe Carrillo Puerto
Fecha: 1-2-2014
Ingeniera en Sistemas Computacionales

Investigacin

Programacin lgica y funcional
Docente: Ing. Paloma Gngora Sabido
Unidad 3: Evaluacin perezosa
Unidad 3: Evaluacin perezosa

1

Contenido

INTRODUCCIN .............................................................................................................................. 2
CONCEPTOS BSICOS DE LA PROGRAMACIN FUNCIONAL PEREZOSA ................. 3
ENFOQUE DE LA EVALUACIN PEREZOSA EN DIFERENTES LENGUAJES ............... 4
En Haskell..................................................................................................................................... 4
En Scheme ................................................................................................................................... 4
EJEMPLOS ....................................................................................................................................... 5
Evaluacin perezosa en Haskell ............................................................................................ 5
En Scheme ................................................................................................................................... 5
PROGRAMACIN CON MODULARIDAD EN LENGUAJE FUNCIONAL ............................ 7
CONCLUSIN .................................................................................................................................. 9
BIBLIOGRAFA .............................................................................................................................. 10


Unidad 3: Evaluacin perezosa

2

INTRODUCCIN
En esta unidad tres de la materia de programacin lgica y funcional el tema central
a abordar es la evaluacin perezosa. Bsicamente la programacin funcional es
aquel que slo est compuesto de funciones que se limitan a hacer corresponder
cada elemento que se le pase como argumento con un valor. No hay variables, por
lo que estas funciones slo tratarn con sus valores de entrada y con constantes
predefinidas; no tienen ms posibilidad de accin.
Parece que esto del concepto de la evaluacin perezosa es una caracterstica de
los lenguajes de programacin funcional, un claro ejemplo de este es el lenguaje
llamado Haskell. Y precisamente la evaluacin perezosa es uno de los rasgos
caractersticos de Haskell, considerando otras caractersticas como las funciones
recursivas o el manejo de listas.
Segn Wikipedia en cuanto a la teora de lenguajes de programacin, la evaluacin
perezosa (del ingls lazy evaluation) o llamada por necesidad es una estrategia de
evaluacin que retrasa el clculo de una expresin hasta que su valor sea
necesario, y que tambin evita repetir la evaluacin en caso de ser necesaria en
posteriores ocasiones.
En la evaluacin perezosa el evaluador hace solamente lo preciso que de forma
literal podra significar hacer slo lo que le pida un patrn a la izquierda de una
ecuacin o cualificador (where o let).
En esta breve investigacin los temas a abarcar son los conceptos bsicos de la
programacin funcional perezosa, el enfoque de la evaluacin perezosa en diferentes
lenguajes, se tratara de dar ejemplos y la programacin con modularidad en el lenguaje
funcional.
Con todo lo que se abordar se espera que se logre comprender los aspectos
bsicos sobre la evaluacin perezosa y entender cmo funciona esto en los
lenguajes funcionales y la finalidad del porqu de su uso.
Unidad 3: Evaluacin perezosa

3


CONCEPTOS BSICOS DE LA PROGRAMACIN FUNCIONAL PEREZOSA

La evaluacin perezosa es una estrategia de evaluacin que retrasa el clculo de
una expresin hasta que su valor sea necesario, tambin puede mejorar la velocidad
del problema, incluso asintticamente, mientras que puede reducir la velocidad por
un factor constante, sin embargo puede producir prdidas de memoria si se usa de
manera incorrecta. Launchbury 1993 discute de manera terica los problemas
relacionados con las prdidas de memoria de evaluacin perezosa, y OSullivan et
al. 2008 da algunos consejos prcticos para el anlisis y la solucin de estos
problemas. Sin embargo, las implementaciones ms generales de evaluacin
perezosa hace un uso extensivo de cdigo sin referencia y los datos llevan a cabo
un funcionamiento pobre en los procesadores modernos con un alto grado
de paralelismo y cachs multinivel, donde un fallo de cach puede producir un coste
de cientos de ciclos de reloj.
La evaluacin mediante paso de parmetros por nombre usando punteros para
compartir valores de expresiones se llama evaluacin perezosa.
En la teora de lenguajes de programacin, la evaluacin perezosa (del ingls lazy
evaluation) o llamada por necesidad es una estrategia de evaluacin que retrasa el
clculo de una expresin hasta que su valor sea necesario, y que tambin evita
repetir la evaluacin en caso de ser necesaria en posteriores ocasiones. Esta
comparticin del clculo puede reducir el tiempo de ejecucin de ciertas funciones
de forma exponencial, comparado con otros tipos de evaluacin.
Los beneficios de la evaluacin perezosa son:
El incremento en el rendimiento al evitar clculos innecesarios, y en tratar
condiciones de error al evaluar expresiones compuestas.
La capacidad de construir estructuras de datos potencialmente infinitas.
La capacidad de definir estructuras de control como abstracciones, en lugar de
operaciones primitivas.
Unidad 3: Evaluacin perezosa

4

La evaluacin perezosa puede tambin reducir el consumo de memoria de una
aplicacin, ya que los valores se crean solo cuando se necesitan. Sin embargo, es
difcil de combinar con las operaciones tpicas de programacin imperativa, como el
manejo de excepciones o las operaciones de entrada/salida, porque el orden de las
operaciones puede quedar indeterminado. Adems, la evaluacin perezosa puede
conducir a fragmentar la memoria.
ENFOQUE DE LA EVALUACIN PEREZOSA EN DIFERENTES LENGUAJES

En Haskell

El mtodo de evaluacin (la forma en que se calculan las expresiones) se llama
evaluacin perezosa (lazy evaluation). Con la evaluacin perezosa se calcula una
expresin (parcial) solamente si realmente se necesita el valor para calcular el
resultado. El opuesto es la evaluacin voraz (eager evaluation). Con la evaluacin
voraz se calcula directamente el resultado de la funcin, si se conoce el parmetro
actual.
Dada la evaluacin perezosa del lenguaje es posible tener listas infinitas. En
lenguajes que usan evaluacin voraz (como los lenguajes imperativos), esto no es
posible.

En Scheme
Una expresin no se evala de inmediato, la evaluacin se pospone hasta el
momento que sea necesaria.
Scheme permite usar evaluacin estricta o perezosa, pero esta ltima debe
programarse de manera explcita:

El valor de una promesa es recordado, de tal forma que si force es llamado
nuevamente, se retorna el valor previamente capturado.
til para trabajar con estructuras de datos infinitas.
Permite pegar programas de una forma completamente distinta.
Unidad 3: Evaluacin perezosa

5

EJEMPLOS

Evaluacin perezosa en Haskell

Este primer ejemplo para una mente acostumbrada a lo imperativo esto cuesta de
entender, as que atencin. Al no tener que seguir una serie de rdenes, una tras
otra, algunos los lenguajes funcionales slo evalan lo que les es requerido en cada
momento. Esto permite cosas como el cdigo Haskell take 5 [1..], que significa
coger los cinco primeros nmeros de una lista infinita de nmeros empezando por
el 1. En un lenguaje imperativo, esto llevara a un bucle infinito mientras se genera
la lista. En Haskell, slo se genera lo que se necesita; en este caso, los cinco
primeros nmeros. Esto puede redundar en una ejecucin ms eficiente y un cdigo
ms claro y cercano al matemtico.
Este segundo ejemplo, tomado de Fokker (95), muestra la potencia de este
concepto. Supongamos la siguiente funcin, para saber si un nmero es primo:

Esta funcin es totalmente perezosa. Por ejemplo, si evaluamos primo 30 pasa lo
siguiente: Primero se calcula el primer divisor de 30: 1.
Se compara este valor con el primer elemento de la lista [1,30]. Para el primer
elemento las listas son iguales.
Despus se calcula el segundo divisor de 30: 2. Se compara el resultado con el
segundo valor de [1,30]: los segundos elementos no son iguales. El operador ==
sabe que las dos listas nunca pueden ser iguales si existe un elemento que difiere.
Por eso se puede devolver directamente el valor false, y as los otros divisores de
30 no se calculan.
En Scheme
Tercer ejemplo

Unidad 3: Evaluacin perezosa

6



Cuarto ejemplo

Quinto ejemplo

Unidad 3: Evaluacin perezosa

7

PROGRAMACIN CON MODULARIDAD EN LENGUAJE FUNCIONAL

Los principios de modularidad y reutilizacin de cdigo en lenguajes funcionales
prcticos son fundamentalmente el mismo que en lenguajes de procedimiento, ya
que ambos se derivan de programacin estructurada. As, por ejemplo:
Procedimientos corresponden a las funciones. Ambos permiten la
reutilizacin del mismo cdigo en varias partes de los programas, y en varios
puntos de su ejecucin.
Del mismo modo, las llamadas a procedimientos corresponden a funcionar la
aplicacin.
Funciones y sus invocaciones son modularmente separados uno de otro de
la misma manera, por el uso de argumentos de la funcin, los valores de
retorno y alcances variables.
La principal diferencia entre los estilos es que los lenguajes de programacin
funcionales eliminar o al menos desenfatizan los elementos imperativos de
programacin procedimental. Por tanto, el conjunto de caractersticas de los
lenguajes funcionales ha sido diseado para apoyar los programas de escritura
tanto como sea posible en trminos de funciones puras:

Considerando que las lenguas de procedimiento modelo de ejecucin del
programa como una secuencia de comandos imperativos que pueden alterar
implcitamente, la programacin funcional idiomas ejecucin del modelo
compartida como la evaluacin de expresiones complejas que slo dependen
unos de otros en cuanto a los argumentos y valores de retorno. Por esta
razn, los programas funcionales pueden tener un orden ms libre de la
ejecucin de cdigo, y los idiomas pueden ofrecer poco control sobre el orden
en que se ejecutan diversas partes del programa.
Lenguajes de programacin funcionales apoyan funciones de primera clase,
funciones annimas y cierres.
Unidad 3: Evaluacin perezosa

8

Lenguajes de programacin funcionales tienden a confiar en la cola de
llamadas y optimizacin de funciones de orden superior en lugar de
construcciones de bucle imperativas.
Muchos lenguajes funcionales, sin embargo, son de hecho impuramente funcional
y ofrecen construcciones imperativas/de procedimiento que permiten al
programador escribir programas en el estilo de procedimiento, o en una
combinacin de ambos estilos. Es comn para la entrada/salida de cdigo en los
lenguajes funcionales que se deben escribir en un estilo procedimental.
S existen algunos lenguajes funcionales esotricos que evitan preceptos
programacin estructurada por el bien de ser difciles de programar. Estos idiomas
son la excepcin a los puntos en comn entre las lenguas de procedimiento y
funcionales.

























Unidad 3: Evaluacin perezosa

9

CONCLUSIN
Antes de entender de un solo golpe el concepto de la programacin funcional
perezosa, considero que previamente se debe de entender que es la programacin
funcional en s.
Los lenguajes habituales que generalmente dominamos se basan, en mayor o
menor medida, en realizar una serie de pasos, o dicho de otra forma en seguir un
algoritmo, esto es en definir lo que las cosas hacen; esto es a lo que se le conoce
como programacin imperativa. En programacin funcional las cosas son muy
diferentes, aqu nosotros definiremos ms bien lo que las cosas son.
El propio nombre nos da una pista o idea de que la caracterstica fundamental de
este paradigma: se basa en un concepto de funcin algo diferente al que estamos
acostumbrados, ms cercano a los conceptos matemticos. No hay variables, por
lo que estas funciones slo tratarn con sus valores de entrada y con constantes
predefinidas; no tienen ms posibilidad de accin. Por esta razn si uno est
acostumbrado al paradigma de tipo imperativo esto podra resultar en un inicio en
algo confuso.
La programacin funcional aun siendo fcil de entender y mantener, suele ser ms
difcil escribir un programa funcionalmente, sobre todo para los que estamos
acostumbrados a la programacin imperativa. La gran variedad de conceptos
complejos sobre todo matemticos a tener en cuenta hace difcil dominar el lenguaje
y producir buen cdigo.
Entonces la programacin funcional perezosa para alguien acostumbrado a
conceptos como el imperativo esto cuesta algo de entender, la programacin
funcional al no tener que seguir una serie de rdenes, una tras otra, los lenguajes
funcionales slo evalan lo que les es requerido en cada momento. En un lenguaje
imperativo como C, esto llevara a un bucle infinito mientras se genera una lista.
Citando a Haskell, este slo genera lo que se necesita; y esto da como resultado
una ejecucin ms eficiente y un cdigo ms claro y cercano a lo matemtico.
Unidad 3: Evaluacin perezosa

10

BIBLIOGRAFA

http://es.wikipedia.org/wiki/Programaci%C3%B3n_funcional
http://www.cs.us.es/~jalonso/publicaciones/2013-Temas_de_PF_con_Haskell.pdf
http://www.genbetadev.com/paradigmas-de-programacion/programacion-funcional-
un-enfoque-diferente-a-los-problemas-de-siempre
http://www.ucasal.edu.ar/htm/ingenieria/cuadernos/archivos/3-p63-Rivadera.pdf
http://www.slideshare.net/t__y__r/programacin-funcional-con-scheme
http://www.slideshare.net/JesusAntonioGarciaLopez1/123507620-
queeslaevaluacionperezosadocx
http://centrodeartigos.com/articulos-noticias-consejos/article_128119.html
http://www.inf.utfsm.cl/~noell/PLP-UCV/apunte04.pdf