3.

1 ESTRATEGIA DE LA EVALUACIN PEREZOSA

Una estrategia de evaluacin es un conjunto de reglas para evaluar
expresiones en un lenguaje de programacin.
Una estrategia de evaluacin define cundo y en qu orden los argumentos a
una funcin son evaluados, cuando se sustituyen en la funcin, y lo que la
sustitucin se forman.
Se puede dar mediante el paso de parmetros por valor o por ms interno. Se
maneja dentro de las expresiones la evaluacin con lambda. Manejan un
procesamiento que puede ser infinito que a su vez trabaja mediante la
evaluacin de pasos de parmetros por valor y mediante pasos de parmetro
por nombre. La evaluacin perezosa e impaciente es la evaluacion mediante
pases de parmetros por nombre, los argumentos pueden evaluarse mas
veces que en paso por valor. Se pueden usar punteros para compartir valores
de expresiones. La evaluacin mediante pase de parmetros por nombre
usando punteros para compartir valores de expresiones se llama evaluacin
perezosa. La evaluacin mediante pasos de parmetros por valor se llama
evaluacin impaciente. Se pueden manejar esta programacin con estructuras
infinitas, dentro de la programacin modular la evaluacin perezosa permite
separar el control de los datos y se puede utilizar en casi todos los tipos de
programaciones para poder hacer comparaciones de consumo de memoria.

Los benefi
cios 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.
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 la
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. Lo contrario de la
evaluacin perezosa sera la evaluacin acaparadora, o
evaluacin estricta, que es el modo de evaluacin por defecto
en la mayora de los lenguajes de programacin.

EJEM PLO S

TERM IN ACI N

N M ERO D E RED UCCIO N ES

ESTRUCTURAS IN FIN ITAS

PRO G RAM ACI N M O D U LAR

APLICACI N ESTRICTA

Prim er ejem plo

 aplicamos masUno

 aplicamos :=

3.2.Tcnicas de program acin funcional

perezosa

La semntica adoptada para el no

determinismo es la de eleccin en la
invocacin (call-time choice), por
resultar mas natural para la
programacin y mas eficaz en la
ejecucin al corresponderse con el
mecanismo de comparticin.

En el no-determinismo existen varias tcnicas como

son:
Tcnica de Backtracking (Prolog):
Si una alternativa falla, el ujo retorna hasta la ltima
decisin e intenta otra.
Tcnica de guardias (guards):
Si ms de una es cierta, se escoge cualquiera de
ellas.
Tcnica de aprendizaje reforzado (A-LISP):
Recordar decisiones exitosas y aumentar su prioridad
as como considerar las decisiones en el contexto del
estado mutable.

Bsqueda no determ inista

Ofrece muchos posibles resultados.

Emplean modelos de computacin tales como la Mquina

de Turing probabilstica, que no son deterministas

Puede simularse utilizando la lista de xitos como por
ejemplo: Soluciones x = x, x candidatos, vlidos
Requiere tipo de datos diferente como son
Data list m a = nil (cons (m a) (m(list a))
Puede representar lista perezosa no determinista
Cons [2] [NIl. cons [1] ]:: list [] int
Los argumentos de cons representan computacin no
determinista, permute y IsSorted se pueden adaptar a la lista
de tipo permute y genera permutaciones perezosamente los
rendimientos IsSorted [true, false] es aplicada por encima de
la lista (s)

Ejem plo en lips

Bibliografa
1. R. Bird. Introduccin a la programacin funcional con Haskell.

Prentice Hall, 2000.

Cap. Cap. 7: Eficiencia.
2. G. Hutton Programming in Haskell. Cambridge University Press,
2007.
Cap. 12: Lazy evaluation.
3. B. OSullivan, D. Stewart y J. Goerzen Real World Haskell.
OReilly, 2008.
Cap. 2: Types and Functions.
4. B.C. Ruiz, F. Gutirrez, P. Guerrero y J.E. Gallardo. Razonando
con Haskell. Thompson, 2004.
Cap. 2: Introduccin a Haskell.
Cap. 8: Evaluacin perezosa. Redes de procesos.
5. S. Thompson. Haskell: The Craft of Functional Programming,
Second Edition. Addison-Wesley, 1999. Cap. 17: Lazy
programming.