Acl Book

Lenguajes de programa
in y modelos
de omputa in
(draft)
Mar elo Daniel Arroyo

Departamento de Computa in
Fa ultad de Cien ias Exa tas, Fsi o-Qumi as y Naturales
Universidad Na ional de Ro Cuarto - Argentina
e-mail: marroyod .exa.unr .edu.ar
Colaborador: Ariel Gonzalez
2008
Resumen
Este libro es el resultado del di tado del urso Anlisis Comparativo de Lenguajes
para alumnos de pregrado en la Universidad Na ional de Ro Cuarto.
Si bien existe una vasta bibliografa en el tema, es dif il en ontrar un ni o libro
que ubriese todos los temas y on el enfoque que bus ado en la asignatura.
Los prin ipales objetivos de este trabajo es re opilar ontenidos de varias fuentes
bibliogr as y ompilarlas desde un enfoque de las ara tersti as de los lenguajes de
programa in a partir de un punto de vista de modelos de omputa i+on y paradigmas
(o estilos) de programa in, desarrollando los on eptos relevantes de los lenguajes de
programa in.
En ada aptulo se desarrollan los on eptos a partir de un lenguaje de programa in bsi o para luego ompararlo on las onstru iones similares en ontradas en
algunos lenguajes de programa in sele ionados.
Los lenguajes de programa in se han sele ionado por su difusin en la industria
y por su importan ia desde el punto de vista a admi o, los uales se analizan en base
a los on eptos bsi os estudiados.
Se ha elegido el enfoque de lenguaje n leo , para el ual se dene su sintaxis y
semnti a (en base a su mquina abstra ta orrespondiente). Luego se irn agregando
adornos sint ti os y otras onstru iones bsi as para ir obteniendo las ara tersti as
a analizar. La semnti a formal permite realizar anlisis de orre titud y su omplejidad omputa ional.
Este material est dirigido a alumnos de segundo o ter er ao de arreras de ien ias de la omputa in o ingeniera de software. Sus ontenidos permiten desarrollar
un urso en uatro meses de dura in on pr ti as de aula y talleres del tipo de los
ejer i ios propuestos en ada aptulo.
Los paradigmas estudiados impli an el modelo
a objetos, lgi o y
el
on urrente.
imperativo, fun ional, orientado
Este ltimo modelo es transversal a los dems
modelos por lo que se ha e un anlisis y onsidera iones en ada ontexto en parti ular.
El lenguaje kernel sele ionado es
Oz, el ual es un lenguaje a admi o desarrollado
espe amente para el estudio de los diferentes modelos de omputa in.
ndi e general
1. Introdu in
1.1.
Lenguajes omo herramientas de programa in
. . . . . . . . . . . . . .
1.2.
Abstra iones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2.1.
Abstra in pro edural
. . . . . . . . . . . . . . . . . . . . . . .
1.2.2.
Abstra in de datos . . . . . . . . . . . . . . . . . . . . . . . . .
1.3.
Evalua in de un lenguaje de programa in . . . . . . . . . . . . . . . .
10
1.4.
Deni in de un lenguaje de programa in . . . . . . . . . . . . . . . . .
11
1.4.1.
1.4.2.
Sintaxis
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
1.4.1.1.
Lenguajes regulares
. . . . . . . . . . . . . . . . . . . .
13
1.4.1.2.
EBNFs y diagramas de sintaxis . . . . . . . . . . . . . .
14
Semnti a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.5.
Herramientas para la onstru in de programas
1.6.
Ejer i ios
1.5.1.
. . . . . . . . . . . . .
Bibliote as estti as y dinmi as . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2. El modelo de larativo
2.1.
Un lenguaje de larativo
2.1.1.
2.2.
2.3.
15
16
18
19
23
. . . . . . . . . . . . . . . . . . . . . . . . . . .
Memoria de asigna in ni a
. . . . . . . . . . . . . . . . . . . .
24
24
2.1.2.
Crea in de valores . . . . . . . . . . . . . . . . . . . . . . . . . .
25
2.1.3.
Un programa de ejemplo . . . . . . . . . . . . . . . . . . . . . . .
26
2.1.4.
Identi adores de variables
. . . . . . . . . . . . . . . . . . . . .
26
2.1.5.
Valores par iales, estru turas li as y aliasing . . . . . . . . . .
27
Sintaxis del lenguaje n leo de larativo
. . . . . . . . . . . . . . . . . .
27
2.2.1.
Valores y tipos de datos . . . . . . . . . . . . . . . . . . . . . . .
28
2.2.2.
Porqu registros y pro edimientos?
. . . . . . . . . . . . . . . .
30
2.2.3.
Adornos sint ti os y abstra iones lingusti as . . . . . . . . . .
30
2.2.4.
Opera iones bsi as del lenguaje
32
. . . . . . . . . . . . . . . . . .
Semnti a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
32
2.3.1.
La mquina abstra ta
. . . . . . . . . . . . . . . . . . . . . . . .
33
2.3.2.
Eje u in de un programa . . . . . . . . . . . . . . . . . . . . . .
34
2.3.3.
Opera iones sobre ambientes
. . . . . . . . . . . . . . . . . . . .
34
2.3.4.
Semnti a de las senten ias . . . . . . . . . . . . . . . . . . . . .
35
2.3.5.
Al an e (s ope) . . . . . . . . . . . . . . . . . . . . . . . . . . . .
36
2.3.6.
Tipado estti o vs dinmi o . . . . . . . . . . . . . . . . . . . . .
38
2.3.7.
Manejo de la memoria . . . . . . . . . . . . . . . . . . . . . . . .
39
2.3.8.
Uni a in (operador '=') . . . . . . . . . . . . . . . . . . . . . .
39
2.3.9.
El algoritmo de uni a in
40
2.3.10. Igualdad (operador

2.4.
Ejer i ios
==)
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
42
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
42
3. lenguajes fun ionales
45
3.1.
Programa in fun ional
. . . . . . . . . . . . . . . . . . . . . . . . . . .
45
3.2.
Cara tersti as prin ipales . . . . . . . . . . . . . . . . . . . . . . . . . .
46
3.3.
Ventajas y desventajas on respe to a la programa in imperativa
47
3.4.
Fundamentos teri os
3.4.1.
3.4.2.
3.5.
3.6.
48
Cl ulo lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . .
49
3.4.1.1.
Redu in
. . . . . . . . . . . . . . . . . . . . . . . . .
50
3.4.1.2.
Computa in y l ulo lambda . . . . . . . . . . . . . .
50
3.4.1.3.
Estrategias de redu in
. . . . . . . . . . . . . . . . .
52
Lgi a ombinatoria . . . . . . . . . . . . . . . . . . . . . . . . .
53
LISP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
55
3.5.1.
Sintaxis
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
55
3.5.2.
Semnti a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
56
3.5.3.
Estado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
56
3.5.4.
Apli a iones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
57
Lenguajes fun ionales modernos . . . . . . . . . . . . . . . . . . . . . . .
57
3.6.1.
3.6.2.
3.7.
. . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . .
ML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
57
3.6.1.1.
58
Tipos de datos estru turados . . . . . . . . . . . . . . .
3.6.1.2.
Referen ias (variables) . . . . . . . . . . . . . . . . . . .
60
3.6.1.3.
Otras ara tersti as imperativas . . . . . . . . . . . . .
60
Haskell
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
61
3.6.2.1.
Tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . .
62
3.6.2.2.
Casos y patrones . . . . . . . . . . . . . . . . . . . . . .
63
3.6.2.3.
Evalua in perezosa y sus onse uen ias . . . . . . . . .
64
3.6.2.4.
Ambientes
. . . . . . . . . . . . . . . . . . . . . . . . .
64
3.6.2.5.
Clases y sobre arga de operadores . . . . . . . . . . . .
65
3.6.2.6.
Emula in de estado . . . . . . . . . . . . . . . . . . . .
66
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
72
Ejer i ios
4. El modelo on estado (statefull)

4.1.
Semnti a de eldas
4.2.
Aliasing
4.3.
4.4.
74
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
76
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
77
Igualdad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
78
. . . . . . . . . . . . . . . . . . . .
78
4.4.1.
Constru in de sistemas on estado
Razonando on estado . . . . . . . . . . . . . . . . . . . . . . . .
79
4.4.2.
Programa in basada en omponentes . . . . . . . . . . . . . . .
79
4.5.
Abstra in pro edural . . . . . . . . . . . . . . . . . . . . . . . . . . . .
80
4.6.
Ejer i ios
81
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5. Lenguajes de programa in imperativos
82
5.1.
De lara iones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
82
5.2.
Expresiones y omandos . . . . . . . . . . . . . . . . . . . . . . . . . . .
83
5.3.
Ex ep iones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
85
5.4.
Introdu in al lenguaje C . . . . . . . . . . . . . . . . . . . . . . . . . .
85
5.5.
Estru tura de un programa C . . . . . . . . . . . . . . . . . . . . . . . .
86
5.6.
El ompilador C
88
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.7.
Compila in de un programa
. . . . . . . . . . . . . . . . . . . . . . . .
88
5.8.
El pre-pro esador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
89
5.9.
Tipos de datos bsi os . . . . . . . . . . . . . . . . . . . . . . . . . . . .
90
5.10. De lara iones y deni iones . . . . . . . . . . . . . . . . . . . . . . . . .
91
5.11. Deni iones de variables . . . . . . . . . . . . . . . . . . . . . . . . . . .
91
5.12. Deni iones de onstantes . . . . . . . . . . . . . . . . . . . . . . . . . .
91
5.13. Deni iones de tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
91
5.14. Fun iones
92
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.15. Al an e de las de lara iones . . . . . . . . . . . . . . . . . . . . . . . . .
93
5.16. Tiempo de vida de las entidades
. . . . . . . . . . . . . . . . . . . . . .
94
5.16.1. Cambiando el tiempo de vida de variables lo ales . . . . . . . . .
95
5.17. Operadores
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.17.1. Asigna in
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.17.2. Expresiones ondi ionales
. . . . . . . . . . . . . . . . . . . . . .
5.17.3. Otras expresiones . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.18. Senten ias de ontrol: omandos
5.18.1. Se uen ia
. . . . . . . . . . . . . . . . . . . . . .
95
96
97
97
97
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
98
5.18.2. Senten ias ondi ionales . . . . . . . . . . . . . . . . . . . . . . .
98
5.18.3. Senten ias de itera in . . . . . . . . . . . . . . . . . . . . . . . .
99
5.18.3.1. Itera in denida

5.18.3.2. Itera in indenida
5.19. Tipos de datos estru turados
. . . . . . . . . . . . . . . . . . . . .
99
. . . . . . . . . . . . . . . . . . . . 100
. . . . . . . . . . . . . . . . . . . . . . . . 100
5.19.1. Arreglos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

5.19.2. Estru turas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
5.19.3. Uniones disjuntas . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
5.20. Punteros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
5.20.1. Ve tores y punteros
. . . . . . . . . . . . . . . . . . . . . . . . . 104
5.20.2. Punteros a fun iones . . . . . . . . . . . . . . . . . . . . . . . . . 107

5.21. Manejo de memoria dinmi a . . . . . . . . . . . . . . . . . . . . . . . . 108
5.22. Estru tura in de programas: mdulos . . . . . . . . . . . . . . . . . . . 108
6. Manejo de la memoria
111
6.1.
Manejo de la memoria e iente
6.2.
Manejo del sta k

6.2.1.
6.3.
. . . . . . . . . . . . . . . . . . . . . . . 111
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
Implementa in del manejo de al an e de ambientes. . . . . . . . 116
Valores reados dinmi amente. Manejo del heap. . . . . . . . . . . . . . 118

6.3.1.
Manejo del heap
6.3.2.
Manejo automti o del heap . . . . . . . . . . . . . . . . . . . . . 120
. . . . . . . . . . . . . . . . . . . . . . . . . . . 119
6.3.3.
Algoritmos de re ole in de basura
. . . . . . . . . . . . . . . . 121
7. Programa in orientada a objetos
123
7.1.
Objetos
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
7.2.
Clases
7.3.
Clases y objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
7.3.1.
Ini ializa in de atributos . . . . . . . . . . . . . . . . . . . . . . 128
7.3.2.
Mtodos y mensajes
7.3.3.
Atributos de primera lase . . . . . . . . . . . . . . . . . . . . . . 129
. . . . . . . . . . . . . . . . . . . . . . . . . 128
7.4.
Heren ia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
7.5.
Control de a eso a elementos de una lase
7.6.
Clases: mdulos, estru turas, tipos? . . . . . . . . . . . . . . . . . . . . 133
7.7.
Polimorsmo
7.8.
Clases y mtodos abstra tos . . . . . . . . . . . . . . . . . . . . . . . . . 134
7.9.
Delega in y redire in . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
7.4.1.
Control de a eso a mtodos (ligadura estti a y dinmi a)
7.10. Reexin
. . . 130
. . . . . . . . . . . . . . . . 133
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
7.11. Meta objetos y meta lases

7.12. Constru tores y destru tores
. . . . . . . . . . . . . . . . . . . . . . . . . 136
. . . . . . . . . . . . . . . . . . . . . . . . 137
7.13. Heren ia mltiple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

7.14. El lenguaje Java (parte se uen ial) . . . . . . . . . . . . . . . . . . . . . 139
7.14.1. Heren ia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
7.15. Genere idad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
7.15.1. Templates (plantillas) de C++
7.16. Ejer i ios
8. Con urren ia
8.1.
. . . . . . . . . . . . . . . . . . . 143
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
148
Con urren ia de larativa . . . . . . . . . . . . . . . . . . . . . . . . . . . 149

8.1.1.
Semnti a de los threads . . . . . . . . . . . . . . . . . . . . . . . 149
8.1.2.
Orden de eje u in . . . . . . . . . . . . . . . . . . . . . . . . . . 150
8.2.
Plani a in de threads (s heduling) . . . . . . . . . . . . . . . . . . . . 152
8.3.
Control de eje u in
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
8.3.1.
Corrutinas
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
8.3.2.
Barreras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
8.3.3.
Eje u in perezosa (lazy)
. . . . . . . . . . . . . . . . . . . . . . 155
8.4.
Apli a iones de tiempo real
. . . . . . . . . . . . . . . . . . . . . . . . . 156
8.5.
Con urren ia y ex ep iones
. . . . . . . . . . . . . . . . . . . . . . . . . 157
8.6.
Sin roniza in . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
8.7.
Con urren ia on estado ompartido . . . . . . . . . . . . . . . . . . . . 158

8.7.1.
8.8.
8.9.
Primitivas de sin roniza in . . . . . . . . . . . . . . . . . . . . . 160
Con urren ia on pasaje de mensajes . . . . . . . . . . . . . . . . . . . . 161

8.8.1.
Semnti a de los puertos . . . . . . . . . . . . . . . . . . . . . . . 162
8.8.2.
Proto olos de omuni a in entre pro esos . . . . . . . . . . . . . 163
Deadlo k
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
8.10. Con urren ia en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

8.11. Ejer i ios
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
9. Programa in Rela ional

9.1.
9.2.
9.1.1.
Las senten ias hoi e y fail
9.1.2.
Arbol de Bsqueda . . . . . . . . . . . . . . . . . . . . . . . . . . 171
9.1.3.
Bsqueda En apsulada . . . . . . . . . . . . . . . . . . . . . . . . 171

La fun in Solve
. . . . . . . . . . . . . . . . . . . . . . . . . . . 173
Programa in Rela ional a Lgi a
. . . . . . . . . . . . . . . . . . . . . 174
Semnti a Opera ional y Lgi a
. . . . . . . . . . . . . . . . . . 175
Prolog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
9.3.1.
Elementos Bsi os
9.3.2.
Clusulas Prolog . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
9.3.3.
Fundamentos Lgi os de Prolog . . . . . . . . . . . . . . . . . . . 180
9.3.4.
9.4.
. . . . . . . . . . . . . . . . . . . . . 170
9.1.4.
9.2.1.
9.3.
170
El modelo de Computa in Rela ional . . . . . . . . . . . . . . . . . . . 170
. . . . . . . . . . . . . . . . . . . . . . . . . . 177
9.3.3.1.
La forma Clausal y las lusulas de Horn
9.3.3.2.
El Prin ipio de Resolu in
9.3.3.3.
Uni a in y Regla de Resolu in
. . . . . . . . 180
. . . . . . . . . . . . . . . . 181
. . . . . . . . . . . . 183
Predi ado ut (!) . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
9.3.5.
Problema de la Nega in
9.3.6.
Predi ado fail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
Ejer i ios
. . . . . . . . . . . . . . . . . . . . . . 188
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
Captulo 1
Introdu in
Los lenguajes de programa in son la herramienta de programa in fundamental
de los desarrolladores de software. Desde los omienzos de la omputa in, la programa in fue evolu ionando desde la simple ongura in de interruptores, pasando
por los primeros lenguajes
assembly,
los uales permitan es ribir las instru iones
de mquina en forma simbli a y la deni in de ma ros, hasta llegar a los lenguajes

de programa in de alto nivel que permiten abstraer al programador de los detalles
de la arquite tura y el desarrollo de programas portables entre diferentes sistemas de
omputa in .
El objetivo de este material es estudiar los on eptos y prin ipios que en ontramos
en los lenguajes de programa in modernos.
Es importante ono er un po o la historia y la evolu in de algunos on eptos para
poder entender algunas ara tersti as de algunos lenguajes.
En la a tualidad (2007) se en uentran atalogados mas de 1500 lenguajes de programa in, por lo ual una urr ula en ien ias de la omputa in o de desarrollo de
software no puede enfo arse en base al di tado de ursos sobre lenguajes on retos,
sino que es ne esario que se estudien lenguajes de programa in desde el punto de
vista de los diferentes modelos o estilos de omputa in en los uales se basan.
Estos modelos o estilos permiten lasi ar a los lenguajes de programa in en familias que generalmente se ono en omo paradigmas.
El estudio de los lenguajes en base al anlisis de ada paradigma permite generalizar
on eptos utilizados en grupos de lenguajes mas que en lenguajes parti ulares.
El enfoque utilizado permite realizar anlisis de los on eptos utilizados en todos
los lenguajes de programa in existentes, permitiendo realizar ompara iones entre
lenguajes o familias.
El estudio de los on eptos y prin ipios generales, en lugar de estudiar la sintaxis
de lenguajes espe os, permite que el desarrollador pueda estudiar y aprender por s
1 Un sistema de omputa in omprende el hardware y el software de base, es de ir, sistema operativo, enlazador, ompiladores, editores, et .
Introdu in
mismo, a utilizar orre tamente las fa ilidades provistas por un nuevo lenguaje (o uno
des ono ido).
Los paradigmas estudiados omprenden el de larativo, dentro del ual podemos
en ontrar el fun ional y el lgi o, el imperativo, en el ual podemos en ontrar una gran
antidad de lenguajes ampliamente utilizados omo Pas al, C, Basi , Ada, FORTRAN,
COBOL, . . . , on sus evolu iones en la programa in orientada a objetos (POO) y los
lenguajes basados en omponentes.
Los on eptos y prin ipios de la on urren ia son apli ables a todos los dems
paradigmas por lo que se estudia omo un paradigma en parti ular analizndose su
apli a in en ada modelo de omputa in en parti ular.
1.1. Lenguajes omo herramientas de programa in

Un lenguaje de programa in permite al programador denir y usar abstra iones.
El desarrollo de software se basa fundamentalmente en la utiliza in de los lenguajes
de programa in y los pro esadores de lenguajes ( ompiladores, intrpretes y linkers).
Las dems herramientas son auxiliares ( omo los editores, entornos integrados de
desarrollo, generadores de Cdigo, et ) y su objetivo es slo ha er ms moda, automatizable y rpida la tarea de produ in de digo.
Los mtodos de desarrollo de software, los uales in luyen lenguajes textuales o
i onogr os, estn basados en los mismos on eptos adoptados en los lenguajes de
programa in .
La arma in anterior es f ilmente veri able ya que ualquier mtodo de desarrollo deber permitir la genera in de digo al menos para algn lenguaje de
programa in.
1.2. Abstra iones

En la se in anterior se arma que un lenguaje de programa in brinda me anismos para la deni in y utiliza in de abstra iones.
Estas abstra iones permiten que el programador tome distan ia de las ara tersti as de bajo nivel del hardware para resolver problemas de una manera mas modular
para que sea f ilmente mantenible a travs de su vida til.
A eptando esta deni in de lo que es un lenguaje de programa in, es mas omprensible que los diseadores de software a gran es ala, generalmente son personas on
amplios ono imientos sobre lenguajes (y su implementa in) y muestra que es imposible que un (buen) diseador de software no haya pasado por una etapa de verdadero
desarrollo de software, es de ir, la es ritura de programas on retos en algn lenguaje
2 En realidad las ara tersti as que en ontramos en los mtodos de desarrollo se pueden en ontrar
en lenguajes de programa in desarrollados on bastante anterioridad.
Introdu in
de programa in que in orpore on eptos modernos omo abstra iones de alto nivel.
La deni in anterior nos permite denir el trmino programa in.
Deni in 1.2.1
La programa in es la a tividad que onsiste en denir y usar abs-
tra iones para resolver problemas algortmi amente.

Es importante omprender as a la programa in ya que esto muestra el porqu
los mejores programadores o diseadores son aquellos que tienen una buena base en
ontenidos en los uales es ne esario una gran apa idad de abstra in omo lo son
algunas reas de la matemti a, la lgi a y el lgebra.
Un lenguaje de programa in generalmente sugiere uno o ms estilos de programa in, por lo que su estudio permite su mejor aprove hamiento en el pro eso de
desarrollo de sotfware.
1.2.1. Abstra in pro edural

Una abstra in pro edural permite en apsular en una unidad sint ti a una omputa in parametrizada.
Es bien ono ida la estrategia de solu in de problemas ono ido omo divide and
onquer (divide y ven ers), la ual se basa en la des omposi in del problema en un
onjunto de subproblemas mas simples y una forma de omposi in de esos subproblemas para obtener la solu in nal.
La abstra in pro edural es la base de la implementa in de esta estrategia de
resolu in de problemas. A modo de ejemplo, la programa in fun ional se ara teriza
por la deni in de fun iones y la omposi in fun ional. La programa in imperativa
se ara teriza por denir la evolu in de los estados de un sistema basndose en la
omposi in se uen ial y en opera iones de ambios de estado (asigna in).
1.2.2. Abstra in de datos

Generalmente los programas operan sobre iertos onjuntos de datos. Es bien ono ido que los ambios mas fre uentemente produ idos en un sistema son los de representa in de los datos que se manipulan. Por este motivo es importante poder o ultar
los detalles de la representa in (o implementa in) de los datos para fa ilitar el mantenimiento y la utiliza in de subprogramas.
Los tipos abstra tos de datos (ADTs) permiten denir tipos de datos uyos valores
estn impl itos o denotados por sus opera iones. Es deseable que los lenguajes de
programa in permitan la espe i a in o implementa in de ADTs o ultando los
detalles de representa in.
Por supuesto no todos los lenguajes lo permiten, pero las tenden ias a tuales han
avanzado en el sentido que las apa idades de modulariza in y o ultamiento de informa in tienden a un mayor ontrol en el en apsulamiento de los omponentes de las
Introdu in
abstra iones.
1.3. Evalua in de un lenguaje de programa in

Un lenguaje de programa in puede ser evaluado desde diferentes puntos de vista.
En parti ular un lenguaje debera tener las siguientes propiedades:
Universal: ada problema omputable
debera ser expresable en el lenguaje.
Esto deja laro que en el ontexto de este libro, a modo de ejemplo, un lenguaje
omo SQL
3 no es onsiderado un lenguaje de programa in.
Natural: on su dominio de su apli a in.

Por ejemplo, un lenguaje orientado al pro esamiento ve torial debera ser ri o
en tipos de datos de ve tores, matri es y sus opera iones rela ionadas.
Implementable: debera
ser posible es ribir un intrprete o un ompilador en
algn sistema de omputa in.
E iente: ada ara tersti a del lenguaje debera poder implementarse utilizando la menor antidad de re ursos posibles, tanto en espa io (memoria) y nmero
de omputa iones (tiempo).
Simple: en uanto a la antidad de on eptos en los uales se basa. A modo de

ejemplo, lenguajes omo PLI y ADA han re ibido mu has rti as por su falta
de simpli idad.
Uniforme:
los on eptos bsi os deberan apli arse en forma onsistente en el
lenguaje. Como un ontraejemplo, en Pas al las senten ias for y while a eptan
una ni a senten ia en su uerpo, mientras que la senten ia repeat a epta un
nmero variable de senten ias en su uerpo.
En C el smbolo * se utiliza tanto para las de lara iones de punteros omo para
los operadores de referen ia in y multipli a in, lo que a menudo onfunde y
da lugar a la es ritura de programas dif iles de entender.
Legible:
Los programas deberan ser f iles de entender. Una rti a a los len-
guajes derivados de C es que son f ilmente onfundible los operadores == y
=.
Seguro: Los errores deberan ser dete tables, preferentemente en forma estti a
(en tiempo de ompila in).
Los lenguajes de programa in son las herramientas bsi as que el programador
tiene en su aja de herramientas. El ono imiento de esas herramientas y mo y en
qu ontexto debe usarse ada uno de ellos ha e la diferen ia entre un programador
3 En
SQL no se pueden expresar lausuras.

10
Introdu in
re in ini iado y un experimentado espe ialista.

Es fundamental que los on eptos sobre lenguajes de programa in estn laros
para poder apli ar (y entender) las otras reas del desarrollo de software omo lo son
las estru turas de datos, el diseo de algoritmos y estru tura in (diseo) de programas omplejos. En denitiva estas tareas se basan siempre en un mismo on epto:
abstra iones.
1.4. Deni in de un lenguaje de programa in

Para des ribir un lenguaje de programa in es ne esario denir la forma de sus
frases vlidas del lenguaje y de la semnti a o signi ado de ada una de ellas.
1.4.1. Sintaxis
Los me anismos de deni in de sintaxis han sido ampliamente estudiados desde
los ini ios de la omputa in. El desarrollo de la teora de lenguajes y su lasi a in[
ha permitido que se denan formalismos de des rip in de lenguajes formales y hasta el desarrollo de herramientas automti as que permiten generar automti amente
programas re ono edores de lenguajes (parsers y lexers) a partir de su espe i a in .

La sintaxis de un lenguaje se espe i a por medio de algn formalismo basado en
gramti as libres de ontexto, las uales permiten espe i ar la onstru in (o deriva in) de las frases de un lenguaje en forma modular.
Las gramti as libres de ontexto ontienen un onjunto de reglas de forma in de
las diferentes frases o ategoras sint ti as de un lenguaje.
Deni in 1.4.1
(VN , VT , S, P ),
Una gramti a libre de ontexto (CFG) es una tupla
VN es el onjunto nito de smbolos no terminales,

onjunto nito de smbolos terminales, S VN es el smbolo de omienzo y
donde
VT es el
P es un
onjunto nito de produ iones.

Los onjuntos VN y VT deben ser disjuntos ((VN VT ) = ) y denotaremos =
VN VT .
P es un onjunto de produ iones, donde una produ in p P tiene la forma
(L, R), donde L VN es la parte izquierda (lhs) de la produ in y R (VN VT ) es
la parte dere ha (rhs).
Por laridad, en lugar de des ribir las produ iones omo pares, se denotar a una
produ in rotulada
p: (X0 , (X1 , . . . , Xnp )),
on
np 0
p : X0 X1 . . . Xnp
y en el aso que
4 Como
np = 0 ,
se es ribir omo:
las populares herramientas lex y ya .

11
omo:
(1.1)
Introdu in
p : X0
(1.2)
De aqu en adelante se asumir que el smbolo de omienzo
apare e en la parte
izquierda de una ni a produ in y no puede apare er en la parte dere ha de ninguna
produ in .
Es omn que un onjunto de produ iones de la forma
abrevie de la forma
{X , . . . , X }
Deni in 1.4.2
Sean
q
enton es X =
G
, (N T )
y sea
q : X
una produ in de P,
se denomina rela in de deriva in y se di e que la adena

G
deriva dire tamente (por apli a in de la produ in p) a .
La rela in
se
X | . . . | .
Cuando se desee ha er expl ita la produ in usada en un paso de deriva in se

q
= .
G
*
Se es ribir = a la lausura reexo-transitiva de la rela in de deriva in.
G
denotar omo
Deni in 1.4.3
Sea G = (VN , VT , S, P ) una gramti a libre de ontexto. Una adena

*
S =
que ontiene slo smbolos terminales ( VT ), se denomina
G
una senten ia de G. Si la adena (VT VN ) ( ontiene no terminales) se denomina
obtenida por
forma senten ial.
Deni in 1.4.4
El lenguaje generado por G, denotado omo

*
L(G) = {w|w VT | S =w}
G
Deni in 1.4.5
Sea el grafo dirigido ST = (K, D) un rbol, donde K es un onjunto

D es una rela in no simtri a, on k0 omo raz, una fun in de rotula in
l : K VT y sean k1 , . . . , Kn , (n > 0), los su esores inmediatos de k0 .
El rbol ST = (K, D) es un rbol de deriva in (o parse tree) orrespondiente a
G =< VN , VT , P, S > si umple on las siguientes propiedades:
de nodos y
1.
M (VN VT )
2.
l(K0 ) = S
3.
S l(k1 ) . . . l(kn )
l(ki ) VT , (1 i n),
ST .
4. Si
o si
n=1
l(k1 ) = ,
enton es
Ki
es una hoja de
l(ki ) VN , (1 i n), enton es ki es la raz del rbol sint ti o para la

gramti a libre de ontexto < VN , VT , P, l(ki ) >.
5. Si
5 Esta
forma se denomina gramti a extendida.

12
Introdu in
Deni in 1.4.6
G =< VN , VT , S, P >. La
k1 . . . kn es la se uen ia formada
Sea ST(G) un rbol de deriva in para
frontera de ST(G) es la adena
l(k1 ) . . . l(kn )
tal que
por las hojas de ST(G) visitadas en un re orrido preorden.
Teorema 1.4.1
Sea
G =< VN , VT , S, P >
y slo si existe un rbol de deriva in para
E > E + E
E > E * E
E > id
una gramti a libre de ontexto,
uya frontera es
*
S =
G
si
E
E
Figura 1.1: Una CFG y un rbol de deriva in.

La gura 1.1 muestra una gramti a libre de ontexto y un rbol de deriva in
para la adena a + b * .
La gramti a dada en la gura 1.1 es ambiga, ya que para una misma adena
existen dos (o ms) rboles de deriva in diferentes. Una gramti a puede desambigarse introdu iendo produ iones que denan la pre eden ia entre los diferentes no
terminales.
Deni in 1.4.7
guaje, es de ir que
Dos gramti as
L(g1 ) = L(g2 )6 .
g1
g2
son equivalentes si generan el mismo len-
Hay gramti as inherentemente ambigas para las uales no existe una gramti a
equivalente no ambiga.
1.4.1.1. Lenguajes regulares

Las palabras que se pueden formar en un lenguaje generalmente se des riben on
formalismos que no requieren des ribir estru turas de las frases. Estos formalismos se
ono en omo las gramti as regulares. Existen otros formalismos equivalentes ampliamente utilizadas, omo las expresiones regulares.
Deni in 1.4.8
nen la forma:
Una
X Ya
gramti a regular es una gramti a uyas produ iones tiey
X a,
donde
X, Y N
a T.
Estas gramti as slo permiten des ribir la onforma in de las palabras o tokens
de un lenguaje lenguaje, pero no es posible des ribir la estru tura de frases. A modo
de ejemplo se muestra una gramti a regular que des ribe la forma in de un valor
entero positivo:
6 La determina in si dos gramti as libres de ontexto son equivalentes es inde idible, es de ir, no
existe un algoritmo que lo determine.
13
Introdu in
N --> N '0' | N '1' | ... | N '9' | '0' | '1' | ... | '9'

El ejemplo anterior muestra que es extenso denir la forma de onstru in de
smbolos de un lenguaje por medio de una gramti a regular, por lo que es omn que
se denan por medio de un formalismo, las expresiones regulares, uya expresividad es
equivalente y permiten deni iones mas ompa tas y legibles.
A ontinua in se da una gramti a libre de ontexto que des ribe la sintaxis de
una expresin regular:
E
|
|
|
|
--> t
E E
(E '|' E)
(E)?
(E)*
-----
se uen ia
alternativa ( hoi e)
op ional ( ero o una vez)
ero o ms ve es
donde t es un smbolo terminal.

Las gramti as regulares extendidas introdu en otras onstru iones ms modas
en la pr ti a omo las siguientes:
E --> [ E ... E
| (E)+
-- set: equivalente a (E | ... | E)

-- una o ms ve es: equivalente a (E(E)*)
1.4.1.2. EBNFs y diagramas de sintaxis

Una Extended Ba kus Naur Form es una extensin de las gramti as libres de
ontexto que permite la des rip in de un lenguaje en forma mas ompa ta.
Informalmente, se puede de ir que permiten es ribir expresiones regulares extendidas en la parte dere ha de las produ iones. Las nota iones mas omunmente mas
utilizadas son:
(S):
S o urre una o mas ve es.
{S}:
[S]:
S o urre ero o mas ve es.
S es op ional ( ero o una vez).
A ontinua in de muestra un ejemplo de una EBNF.
...
var-de l --> var id {',' id} ':' type ';'
type
--> integer | real | ...
...
if-stmt --> if ondition then stmt [ else stmt
...
14
Introdu in
const_decl
type_decl
decl
var_decl
proc_fun_decl
var_decl
"var"
id
":"
id
";"
Figura 1.2: Ejemplo de diagramas de sintaxis.
Los diagramas de sintaxis son una representa in gr a por medio de un grafo
dirigido el ual muestra el ujo de apari in de los omponentes sint ti os. Los nodos
del grafo orresponden a los smbolos terminales y no terminales y los ar os indi an
el smbolo que puede seguir en una frase. Es omn que los nodos orrespondientes
a los smbolos terminales se denoten on r ulos y los nodos que orresponden a no
terminales se denoten omo valos.
La gura 1.4.1.2 muestra un ejemplo de diagramas de sintaxis.
1.4.2. Semnti a
La semnti a de un lenguaje de programa in des ribe el signi ado, omportamiento o efe tos de las diferentes frases del lenguaje.
Es muy omn que en los manuales de los lenguajes de programa in la semnti a
de ada una de las frases de des riba de manera informal.
Esta informalidad ha llevado mu has ve es a onfusiones en los programadores o
los implementadores de herramientas omo ompiladores e intrpretes, ausando que
los resultados de un programa en una implementa in no sean los mismos que en otra .
Para dar una deni in pre isa de la semnti a de un lenguaje es ne esario utilizar
algn formalismo que des riba en forma lara y no ambiga el signi ado de las frases.
Se han utilizado diferentes estilos de formalismos para dar semnti a:
Denota ional:
ada onstru in del lenguaje se rela iona on alguna entidad
matemti as (ej: onjuntos, fun iones, et ) que representa el signi ado de ada
estru tura.
Esta forma de dar semnti a es til desde el punto de vista teri o, pero en
general no es modo para los implementadores de lenguajes y los desarrolladores.
Opera ional:
des rip in del efe to o eje u in de ada onstru in del len-
guaje en una mquina abstra ta dada. Una mquina abstra ta est basada en
algn modelo de omputa in.
7 Esto
ha su edido en C, C++, FORTRAN, y hasta en los lenguajes de re iente apari in.

15
Introdu in
Esta forma es til tanto para los implementadores del lenguaje omo para los desarrolladores de programas, ya que tienen una visin mas on reta (opera ional)
del lenguaje.
Axiomti a: des rip in de ada onstru in del lenguaje en trminos de ambios de estado. Un ejemplo es la lgi a de Hoare, que es muy til para el desarrollo
y veri a in formal de programas imperativos.
Esta t ni a es til para los desarrolladores pero no demasiado buena para los
implementadores del lenguaje.
En este libro se utilizar la semnti a opera ional para dar el signi ado al lenguaje
que se ir desarrollando en ada aptulo, siguiendo la idea de lenguaje n leo (kernel)
el ual permite dar una sintaxis y semnti a de manera sen illa para luego adornar
el lenguaje on mejoras sint ti as (synta ti sugars) y abstra iones sint ti as o
lingsti as pr ti as, las uales tendrn un patrn de tradu in al lenguaje n leo.
1.5. Herramientas para la onstru in de programas

El programador uando utiliza un lenguaje de programa in, utiliza herramientas
que implementan el lenguaje. Estas herramientas son programas que permiten eje utar
en la plataforma de hardware utilizada las onstru iones del lenguaje de alto nivel.
En general se disponen de las siguientes herramientas:
Compilador:
tradu e un programa fuente a un programa assembly u objeto
(ar hivo binario enlazable).
Intrprete:
programa que toma omo entrada programas fuentes, genera una
representa in interna ade uada para su eje u in y evala esa representa in

emulando la semnti a de las onstru iones del programa dado.
Es posible en ontrar intrpretes de bajo nivel, tambin ono idos omo eje utores
de programas. Estos eje utores interpretan lenguajes de bajo nivel (assembly real
o hipotti o).
Es omn que una implementa in de un lenguaje venga a ompaado por un
ompilador a un assembly de una mquina abstra ta y un intrprete de ese
lenguaje de alto nivel. Ejemplos de esto son algunos ompiladores de COBOL,
Pas al (se tradu a a P- ode).
A tualmente uno de los asos mas ono idos sea Java. Es omn que un ompilador de Java traduz a los mdulos a un assembly sobre una mquina abstra ta
ono ida omo la Java Virtual Ma hine (JVM).
Este ltimo enfoque permite obtener portabilidad binaria, ya que es posible eje utar un programa en ualquier plataforma que tenga una implementa in (intrprete) de la mquina abstra ta.
16
Introdu in
Enlazador (linker):
un ar hivo objeto puede ha er referen ia a smbolos (va-
riables, rutinas, et ) de otros ar hivos objetos. Estas referen ias se denominan
referen ias externas. El linker toma un onjunto de ar hivos objetos8 , arma una
imagen en memoria, resuelve las referen ias externas de ada uno (asigna dire iones de memoria on retas a ada referen ia externa no resuelta) y genera un
ar hivo binario eje utable (programa ).
En forma ms rigurosa, un linker bsi amente implementa una fun in que toma
una referen ia a un smbolo externo y retorna la dire in de memoria de su
deni in.
Generalmente ada ar hivo objeto se orresponde on un mdulo del programa

fuente. La modulariza in es til para dividir grandes programas en unidades
lgi as reusables.
Adems, los ambientes de desarrollo generalmente vienen a ompaados por mdulos bsi os para ha erlo mas til en la pr ti a (mdulos para ha er entradasalida, fun iones matemti as, implementa in de estru turas de datos, et ) lo
que omnmente se ono e omo la bibliote a estndar del lenguaje.
if
archivo
fuente
Analizador
lexico
(lexer)
tokens
if ( ...
Analizador
sintactico
(parser)
Analizador
Semantico
(type checker)
(
...
Optimizador
mov ax,...
generador
de codigo
codigo
(assembly)
assembler
archivo
objeto
Compilador
archivo
objeto
resolucion de
referencias
externas
edicion
archivo
ejecutable
(programa)
biblioteca
Linkeditor (linker)
Figura 1.3: Esquema de ompila in de un programa.
La gura 1.3 muestra un esquema del pro eso de ompila in de un programa.
8 Generalmente
llamados mdulos binarios.

17
Introdu in
1.5.1. Bibliote as estti as y dinmi as

Una bibliote a es un ar hivo que ontiene ar hivos objeto.
Generalmente un programa de usuario se enlaza on al menos unas uantas rutinas bsi as que omprenden el sistema de tiempo de eje u in (runtime system ). El
runtime system generalmente in luye rutinas de ini io (start-up) de programas , y la

implementa in de otras rutinas bsi as del lenguaje.
Cuando en el programa obtenido se in luye el digo (y posiblemente datos) de las
rutinas de bibliote a utilizadas se denomina enlazado estti o (stati linking).
Un programa enlazado estti amente tiene la ventaja que uando se lo transporta
a otra omputadora tiene todas sus dependen ias resueltas, es de ir que todas sus
referen ias (a datos y digo) estn resueltas y todo est ontenido en un ni o ar hivo
binario.
Los primeros sistemas de omputa in generalmente soportaban este ni o tipo de
enlazado. De aqu el nombre a estos linkers ono idos omo link-editores.
A medida que el tamao de los programas re e, el uso de bibliote as generales
es omn. Ms an, en los sistemas multitarea (o multiprograma in), omienzan a
apare er varias desventajas y el me anismo de enlazado estti o se torna pr ti amente
inviable.
Las prin ipales desventajas son:
El tamao de los programas se ha e muy grande.
En un sistema multitarea hay grandes antidades del mismo digo repli ado en
la memoria y en el sistema de ar hivos.
No tiene en uenta la evolu in de las bibliote as, uyas nuevas versiones pueden
orregir errores o mejorar su implementa in.
Por este motivo apare e el enfoque de las bibliote as de enla e dinmi o
10 (DLLs).
Este enfoque requiere que el sistema operativo ontenga un linker dinmi o, es

de ir que resuelva las referen ias externas de un mdulo (ar hivo objeto) en tiempo
de eje u in.
Cuando un pro eso (instan ia de programa en eje u in) ha e referen ia a una
entidad uya dire in de memoria no haya sido resuelta (referen ia externa), o urre
una trampa (trap) o ex ep in generada por el sistema operativo. Esta trampa dispara
una rutina que es la en argada de realizar el enla e dinmi o.
Posiblemente se requiera que el digo (o al menos la parte requerida) de la bibliote a sea argada en la memoria (si es que no lo estaba).
Cabe ha er notar que los ar hivos objetos deben a arrear mas informa in de utilidad por el linker dinmi o. Un programa debe a arrear la lista de bibliote as requeridas
9 Una rutina de startup generalmente abre ar hivos de entrada-salida estndar e invo a a la rutina
prin ipal del programa.
10 En el mundo UNIX son ono idas omo shared libraries.
18
Introdu in
y ada ar hivo objeto de ada bibliote as debe ontener al menos el onjunto de smbolos que exporta.
Las prin ipales ventajas que tiene este me anismo son:
El digo de las rutinas de las bibliote as se en uentra presente una sola vez (no
hay mltiples opias).
El digo se arga baja demanda. Es de ir que no se argar el digo de una
bibliote a que no haya sido utilizada en una instan ia de eje u in.
Como desventaja tiene que la eje u in de los programas tiene una sobre arga adi ional (overhead) que es el tiempo insumido por la resolu in de referen ias externas
y la arga dinmi a de digo.
Un linker on apa idades de generar bibliote as dinmi as deber generar ar hivos
objetos on la informa in adi ional que men ionamos arriba y el sistema operativo
deber permitir eje utar digo reubi able, es de ir independiente de su ubi a in en
la memoria
11 .
Una bibliote a ompartida no debera tener estado propio, ya que puede ser utilizada por mltiples pro esos en forma simultnea, es de ir que es un re urso ompartido
por varios pro esos. Por ejemplo, un programador de una bibliote a que pueda utilizarse en forma ompartida no podr utilizar variables globales.
Lo anterior es muy importante a la hora de disear bibliote as. Es bien ono ido
errno),
el aso de la bibliote a estndar de C, la ual dene una variable global (
la
ual ontiene el digo de error de la ltima llamada al sistema realizada.

Al querer ha er la bibliote a de C ompartida, los desarrolladores tuvieron que
implementar un atajo para solu ionar este problema.
1.6. Ejer i ios

Nota: los ejer i ios estn planteados para ser desarrollados en un sistema que disponga de las herramientas de desarrollo omnmente en ontrados en sistemas tipo
UNIX. El pr ti o se puede desarrollar en ualquier plataforma que tenga instaladas
las herramientas bsi as de desarrollo del proye to GNU (software libre) instaladas.
Herramientas ne esarias: g (GNU Compiler Colle tion), gp (GNU Pas al Compiler), ld, grep y w .
1. Denir una expresin regular que denote un identi ador en Pas al.
2. Denir un autmata nito que a epte el lenguaje denotado por la expresin
regular del ejer i io anterior.
11 Esto
se logra utilizando algn me anismo de memoria virtual (segmenta in o paginado)

19
Introdu in
3. Usar el omando
grep12
que sele ione las lneas del ar hivo fuente Pas al del
ej. 1 los siguientes patrones:
a ) Las lneas que ontengan Var

b ) Las lneas on omentarios
) Comparar la antidad de begin y la antidad de end en un programa Pas al.
Ayuda: usar grep y w .
4. Dar una EBNF que dena las senten ias de Pas al.
5. Implementar un programa que re onoz a frases segn la siguiente EBNF:
E T [ + E]
T F [ T ]
F V | ( E )
V ( 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 )+
Ayuda: Por ada regla de la gramti a de la forma
X a Y b
se puede denir
un pro edimiento on la forma:
Pro edure X;
begin
if urrent_token = 'a' then begin
next_token;
Y
end
else
error;
if urrent_token = 'b' then
next_token
else
error
end;
donde next_token es un pro edimiento que obtiene el prximo (smbolo) token
de la entrada.
Para sta gramti a next_token debera re ono er (y obtener) valores numri os
y los smbolos + y * (e ignorar espa ios, tabs y new-lines).
Generar patrones de digo para reglas que ontengan omponentes op ionales
(0 o una vez) y repeti iones (0 o mas y 1 o mas).
6. Extender el programa anterior para que evale la expresin.
Ayuda: utilizar una pila de operandos y una pila de operadores.
12 Uso:
grep expresin-regular [le. Para mas informa in ha er "man grep".

20
Introdu in
7. Dado el siguiente programa Pas al y el siguiente fragmento de digo C. El

programa CallToC de lara una variable externa, le asigna un valor e invo a a un
pro edimiento externo, el ual est implementado en C (en el mdulo in . ),
Program CallToC;
Var x:integer; external name 'y';
Pro edure in _x; external name 'in _y';
begin { programa prin ipal }
x := 1;
in _x;
writeln('x=',x)
end.
/* file in . */
int y;
/* global integer y */
void in _y(void)
{
y++;
}
a ) ompilar el programa Pas al (usando gp ). En aso de error des ribir su
origen y quin lo genera ( ompilador o linker).
b ) ompilar el fragmento de programa C para obtener el ar hivo objeto orres-
13 analizando los pasos realizados. Usar el omando objdump -t
pondiente
in .o para ver los smbolos denidos en el ar hivo objeto.

) generar un ar hivo eje utable en base a los dos mdulos.
d ) des ribir qu pasos se realizaron ( ompila in, assembly, linking) en el punto
anterior.
8. Generar una bibliote a estti a (llamada libmylib.a ) que ontenga el ar hivo
objeto in .o (del ejer i io anterior) on la utilidad ar.
Usar el siguiente programa C (el ual invo a a
inc_y()) para ompilarlo enlazarlo
on la bibliote a mylib.
int main(void)
{
in _y();
}
9. Re ompilar el programa Pas al denido arriba usando la bibliote a reada en el
ejer i io anterior.
13 Usar
el omando g -v - in . .
21
Introdu in
10. El siguiente programa C muestra la arga de una bibliote a dinmi a (math), la

resolu in de una referen ia (externa) a la fun in os (denida en math) y la
invo a in a os(2.0).
/* File:
#in lude
#in lude
#in lude
foo. */
<stdio.h>
<stdlib.h>
<dlf n.h>
int main()
{
void *handle;
double (* osine)(double); /* Pointer to a fun tion */
/* Load the math library */
handle = dlopen("libm.so", RTLD_LAZY);
/* Get (link) the " os" fun tion: we get a fun tion pointer */
osine = (double (*)(double)) dlsym(handle, " os");
printf("%f\n", osine(2.0));
dl lose(handle);
exit(EXIT_SUCCESS);
Compilar el programa ( on el omando g -rdynami -o foo foo. -ldl ) y eje utarlo.
22
Captulo 2
El modelo de larativo
La programa in omprende tres osas:
Un modelo de omputa in, el ual dene formalmente la sintaxis y la semnti a
de las frases (senten ias) del lenguaje.
Un onjunto de t ni as de programa iny prin ipios de diseo. Generalmente
sto se ono e omo el modelo (o estilo) de programa in.
Un onjunto de t ni as para razonar sobre los programas y al ular su e ien ia.
Otros autores llaman a los tres puntos que ara terizan a familias de lenguajes
omo que denen un paradigma de programa in.
El modelo que se presentar es el modelo de larativo, el ual dene me anismos
bsi os para evaluar fun iones par iales (o fun iones sobre estru turas de datos par iales).
Este modelo se ono e omunmente omo programa in sin estado (stateless),
opuesto a la programa in on estados (statefull) o programa in imperativa.
El trmino imperativo se reere a que el programador ve a los programas omo una
se uen ia de omandos que ambian el estado (valores de un onjunto de variables)
para llegar a obtener el efe to del programa deseado. En aso que los programas arrojen resultados, el estado nal se orrespondera on el resultado del programa.
La programa in de larativa omprende bsi amente dos paradigmas de larativos,
el paradigma fun ional y el lgi o.
Estos paradigmas omprenden la programa in en base a fun iones sobre valores
ompletos omo Sheme y ML, omo tambin a la programa in no determinsti a sobre rela iones, omo Prolog.
Una de las grandes ventajas de la programa in de larativa es que es mas simple el razonamiento sobre los programas ya que al no tener estado es posible ha er
razonamiento en forma modular.
23
En estos modelos, es omn que la programa in est basada en deni iones re ursivas (tanto de fun iones omo de datos), lo que permite razonar en trminos matemti os utilizando el prin ipio de indu in (natural y estru tural).
Como desventaja es ne esario men ionar que hay algunos problemas que pare en
ser modelados mas naturalmente on la no in de estado, omo lo son la entrada-salida,
omputa iones usando evalua in par ial, et .
Si bien lo anterior es posible modelarlo sin estado, las implementa iones son mas
omplejas y dif iles de entender.
2.1. Un lenguaje de larativo

Como se vio en el aptulo anterior, aqu se utilizar el enfoque del lenguaje n leo
para des ribir la sintaxis y la semnti a del lenguaje a utilizar.
El modelo de larativo requiere que las variables no sean modi ables, slo ini ializables, es de ir que una vez que tomaron un valor stas no pueden tomar otro.
2.1.1. Memoria de asigna in ni a

Las variables en sta memoria estn ini ialmente no ligadas y pueden ser ligadas
slo una vez.
Una ligadura es una aso ia in entre una variable y un valor.
Una variable ligada es indistiguible de su valor.
La memoria ontendr alma enados valores, esto es, estru turas de datos que representan valores del lenguaje y variables de larativas. Estas variables se representarn
omo referen ias a valores, uando estn ligadas. Las variables no ligadas no ha en
referen ia a ningn valor.
x1
3.14
x2
person
name
x3
unbound
age
25
Figura 2.1: Ejemplo de la memoria onteniendo variables y valores.

El lenguaje podr determinar si una variable est ligada o no, lo ual requiere que
la representa in de las variables o, que tengan un tag indi ando si estn ligadas o no,
o que las variables no ligadas hagan referen ia a un valor espe ial que lo distinga de
24
los dems.
La gura 2.1 muestra un ejemplo de la memoria de variables y valores en el modelo de larativo. La gura ilustra la representa in de un valor Integer y del Re ord
person(name:Y age:25), donde el identi ador Y orresponde a la variable x3 la ual
no est ligada.
No se deben onfundir las variables on los identi adores ya que es posible que
algunas variables se identiquen en el programa por medio de indenti adores, mientras
que otras pueden no estar nombradas en el programa (pero s tal vez denotada por
alguna expresin). Generalmente esas variables se denominan mudas.
Adems un mismo identi ador puede estar aso iado a una variable en un ontexto (ambiente) y a otra variable en otro, omo omnmente o urre en lenguajes que
permiten denir mltiples ambientes.
Se debe notar que los valores pueden ser valores par iales, esto es una estru tura
puede ontener omponentes no ligados (unbounded).
En este sentido el lenguaje que se est introdu iendo es ms general que las variables de algunos lenguajes fun ionales omo por ejemplo ML o Haskell. Los lenguajes
fun ionales se ara terizan por el he ho que todas sus variables estn ligadas desde
el momento de su introdu in. Esto quiere de ir que la rea in de una variable va
a ompaada de su valor.
2.1.2. Crea in de valores

La opera in bsi a sobre la memoria de valores y variables es la rea in de valores.
Una senten ia de la forma
X = 25
rea la estru tura de datos para representar el valor 25 (ej: un bloque de memoria
de 4 bytes) y liga la variable identi ada por
al valor.
El lenguaje n leo del modelo de larativo permite la rea in de los siguientes tipos
de valores:
1. Nmeros (enteros y reales).
Los ara teres sern representados omo nmeros (su digo orrespondiente
segn la odi a in utilizada, ej: ASCII o Uni ode).
2. Registros. Ejemplo:
person(name:George age:25).
3. Pro edimientos. En el lenguaje n leo los pro edimientos son valores a diferen ia
del paradigma imperativo. El uso de pro edimientos omo valores otorga una
gran exibilidad para denir onstru iones de mas alto nivel.
En los programas de ejemplo usaremos denota iones de la forma [x1 x2 . . . xn para representar listas. Las listas se representarn omo registros de la forma list(X1:x1
25
X2:x2 . . . XN:xn).
Tambin denotaremos tuplas de la forma tuple(x1 x2 . . . xn), las uales se representarn omo registros de la forma tuple(1:x1 2:x2 . . . n:xn).
2.1.3. Un programa de ejemplo

El siguiente programa dene un pro edimiento que al ula el fa torial de un nmero
entero positivo.
lo al Fa torial in
Fa torial = pro {$ N ?R}
if N == 0 then R = 1 else R = N * { Fa torial N - 1 } end
end
end
lo al F in
F = {Fa torial 5} invo a in a Fa torial(5)
{Browse F}
end
Figura 2.2: Programa de ejemplo en el lenguaje n leo de larativo.

Asumiremos que el pro edimiento
Browse es
un pro edimiento predenido (built-
in) en la bibliote a estndar del lenguaje, el ual muestra por onsola (salida estndar)
el valor pasado omo argumento.
2.1.4. Identi adores de variables

Las variables men ionadas en el texto de un programa son identi adores de variables. En el ejemplo anterior, el identi ador X sirve de nombre para una variable (ej:
x1 )
la ual est ligada al valor 25.

La distin in entre variables e identi adores es importante para poder omprender
la semnti a que se dar mas adelante.
store
"X"
3.14
Figura 2.3: Identi adores y variables.
Los identi adores se en uentran fuera de la memoria de variables y valores . En
1 Se
en uentran en el ambiente, lo ual es un mapping de identi adores en variables del store.

26
el lenguaje n leo, los identi adores se denotarn en mays ulas y utilizaremos mins ulas para referirnos a las variables dentro de la memoria de asigna in simple.
Deni in 2.1.1
Un
ambiente es un onjunto de aso ia iones (pares) de identi a-
dores y variables.
Los identi adores de variables estarn ontenidos en un rea separada de memoria.
De he ho en los lenguajes ompilados, los identi adores (es de ir, el ambiente) no
existen en tiempo de eje u in. Estos son slo identi adores que utiliza el ompilador
para ligar nombres on variables .

La gura 2.3 muestra la diferen ia entre variables e identi adores.
2.1.5. Valores par iales, estru turas li as y aliasing

La gura 2.1 muestra un ejemplo de un valor onstruido par ialmente. El registro
(re ord)
person(name:X age:25)
identi ador X (es de ir,
x3)
es un valor par ial, ya que la variable aso iada al
no est ligada a ningn valor.
El lenguaje tambin permite des ribir estru turas li as, tal omo el siguiente
ejemplo:
X = node(value:345 tail:X)
Dos variables pueden referirse al mismo valor, por lo tanto en un programas los
identi adores orrespondientes tambin lo harn. Esto se denomina aliasing ya que
puede haber varias variables denotando el mismo valor.
El on epto de aliasing obrar mayor importan ia durante el estudio del paradigma
imperativo ya que en general se onvierte en algo no deseable a la hora de razonar sobre
los programas.
El problema es que uando se ambia el valor de una variable, ese ambio se reejar
automti amente en las dems variables ligadas entre ellas.
En el modelo de larativo el aliasing no genera problemas ya que las variables ligadas son inmutables.
El lenguaje de larativo permite uni ar (igualar) dos variables. La senten ia
X = Y
liga las variables X e Y. Esta senten ia se denomina variable-variable binding.
2.2. Sintaxis del lenguaje n leo de larativo

La gura 2.4 des ribe por medio de una EBNF la sintaxis del lenguaje n leo de larativo.
2 En realidad las variables se orresponden on dire iones de memoria o ndi es de una tabla. Un
ambiente omnmente se denomina tabla de smbolos.
27
< s > ::=

|
|
|
|
|
|
|
< s >1 < s >2

< x > in < s > end
< x >1 =< x >2
< x >=< v >
if < x > then < s >1 else < s >2 end
ase < x > of < pattern > then < s >1
else < s >2 end
{ < x > < y >1 . . . < y >n }
lo al
|
<v>
< number >
< record >
< pattern >
senten ias
senten ia va a (sin efe to)
omposi in se uen ial
rea in de variable
ligadura variable-variable
rea in de valor
Condi ional
skip
::=
::=
::=
::=
Pattern mat hing

Apli a in pro edural
< number >|< record >|< procedure >

< integer >|< f loat >
< pattern >
< literal >
< literal > (< f ield >1 : x1 . . . < f ield >n : xn )
< atom >|< bool >
< literal >|< integer >
false | true
|
< literal > ::=
< f ield > ::=
< bool > ::=
valores
nmeros
re ords
patrones
booleans
Figura 2.4: Sintaxis del lenguaje n leo de larativo.
Las denota iones para las listas y tuplas sern adornos sint ti os para ha er ms
legibles los programas, pero se representern omo registros omo se men ion anteriormente.
Las adenas de ara teres (strings) sern reprentados omo listas de enteros pero
se denotarn entre omillas dobles, tal omo es habitual en la mayora de los lenguajes
de programa in.
2.2.1. Valores y tipos de datos

Deni in 2.2.1
Diremos que un
tipo de datos es una des rip in de un onjunto
de valores junto on las opera iones que se apli an sobre ellos.

Cada valor orresponde a un tipo de datos. Un valor
es de un tipo
si
v T.
El lenguaje de larativo des ripto aqu es un lenguaje tipado ya que los valores pertene en a tipos de datos bien denidos, llamados tipos bsi os. Estos tipos bsi os
pueden lasi arse en la jerarqua de la gura 2.5.
Entre los tipos bsi os tenemos dos lases:
1.
elementales:
(tambin llamados bsi os) tales omo los nmeros y literales.
Estos valores son indivisibles.

2.
estru turados:
(o ompuestos) omo lo son los re ords. Son estru turas om-
puestos por otros valores.

Cabe a larar que en otros lenguajes de programa in existen otros tipos de datos
bsi os omo las referen ias y los arreglos.
28
Value
Number
Integer
Float
Record
Procedure
Tuple
Function
Literal
Char
Bool
List
Atom
String
Figura 2.5: Jerarqua de tipos bsi os.
Los tipos de datos estru turados pueden lasi arse en base a diferentes ara ters as.
Por el tipo de sus elementos que ontienen:
1.
homogneos:
todos sus elementos son del mismo tipo, omo por ejemplo los
arreglos.
2.
heterogneos: sus elementos pueden ser de diferente tipo, omo los registros.
Por sus ara tersti as del manejo de sus elementos:

1.
estti os: el nmero de sus elementos est dado por una onstante momento de
su rea in. Ejemplo: arreglos en Fortran o Pas al.
2.
dinmi os: el nmero de sus elementos es variable. Ejemplos: listas, arreglos y

registros dinmi os, . . . .
3.
semi-dinmi os:
el nmero de elementos est determinado por una variable
en su rea in pero luego el nmero de sus elementos se mantiene. Ejemplos:

arreglos de C o C++.
Las estru turas de datos estti as permiten una implementa in mas e iente, ya
que la antidad de memoria a asignar para su representa in es ono ida en tiempo de
ompila in y por lo tanto se pueden utilizar t ni as de manejo de memoria estti a
o mediante una pila.
Los arreglos y los registros estti os o semi-dinmi os permiten una representa in
ontiga de sus elementos, lo que permite la implementa in simple de sus operadores
de a eso a sus elementos, generalmente ono idas omo sele tores .
3 Como
los operadores . de los registros y [ de los arreglos.

29
2.2.2. Porqu registros y pro edimientos?

Los registros son una estru tura muy til para representar otros tipos de datos
omo las tuplas y listas. Adems los registros permiten des ribir datos omo por ejemplo omponentes gr os de un sistema de genera in de interfa es de usuario.
Los pro edimientos son ms generales que las fun iones en el sentido que es posible
simular fun iones asumiento que son pro edimientos on un argumento adi ional al
nal el ual se utilizara para retornar el resultado.
Se utilizar la nota in
?Arg para denotar un
parmetro formal que ser utilizado
omo valor de salida en un pro edimiento. En ste modelo se requerir que el parmetro
a tual (o real) no est ligado en el momento de la invo a in.
El smbolo ? permite dar laridad sint ti a a la deni in de un pro edimiento
pero no tiene ninguna semnti a parti ular.
2.2.3. Adornos sint ti os y abstra iones lingusti as

Un adorno sint ti o (synta ti sugar) es una nota in mas ompa ta (short ut)
de frases del lenguaje que se utilizan fre uentemente. Un adrono sint ti o no provee
una nueva abstra in sino ha e una nota in mas onveniente o ompa ta.
Se permitirn varios adornos sint ti os.
lo al: en lugar de es ribir algo omo

if N == 1 then s
else
lo al L in
Senten ia
end
end
...
podemos es ribir
else L in
end
if
N == 1
then s
...
lo al es permitir la de lara in de varios identilo al A B ... in . . . end, lo ual ser equivalente al siguiente
Otro adorno en una senten ia

adores de la forma
esquema:
lo al A in
lo al B in
end
end
...
30
Expresiones: Las expresiones representan valores y se forman en base a valores

y operadores. La evalua in de una expresin arroja un valor de un tipo determinado. Un operador es una fun in sobre valores de un tipo determinado. Se
permitir en el lenguaje que se es riban senten ias de la forma
D)
A = B * (C +
la ual ser tradu ida al lenguaje n leo omo
lo al T1 T2 in
{Number.`+` C D T1}
{Number.`*` B T1 T2}
end
A = T2
donde los pro edimientos
Number.`+` y Number.`*` pertene en al mdulo Number4.
En las expresiones es posible utilizar parntesis para aso iar opera iones.
El lenguaje n leo tendr en uenta la pre eden ia y aso iatividad entre los
operadores bsi os del lenguaje de la manera habitual en otros lenguajes de
A + B * C signi a A + (B * C)
A+B+C signi a (A+B)+C (aso iatividad).
programa in. Por ejemplo la expresin

eden ia) y la expresin
(pre-
Deni in de pro edimientos: se podr utilizar la nota in

pro { P X1 . . . Xn } . . . end en lugar de
P = pro { $ X1 . . . Xn } . . . end
Una abstra in lingusti a introdu e una nueva abstra in para ha er ms modo el lenguaje pero similarmente a los adornos sint ti os tienen un patrn de
tradu in al lenguaje n leo.
Un ejemplo de abstra in sint ti a que se permitir en el lenguaje de larativo es
la deni in de fun iones. Una deni in de la forma
fun { $ A B . . . } . . . < expr > end

se tradu ir omo
pro { $ A B . . . ?R } . . . R = < expr > end

donde
< expr >
ser una expresin que deber ser eje utada al nal de la fun in.
Las invo a iones a fun iones podrn formar parte de las expresiones.
Una fun in se podr denir omo los pro edimientos des riptos arriba. Es de ir
que en el ejemplo 2.2, la fun in
Fa torial se podra denir
fun { Fa torial N }
if N == 0 then R = 1
else R = N * { Fa torial N - 1 }
end
end
4 Los
mdulos se des ribirn en aptulos subsiguientes.

31
de la forma
Otra abstra in lingusti a denida ser la ini ializa in de variables en la sen-
lo al. De este modo, por ejemplo, podremos es ribir:

lo al X=1 Y=2*X in . . . end
ten ia
uya tradu in al lenguaje n leo es natural y se deja omo ejer i io.
2.2.4. Opera iones bsi as del lenguaje

Operador
Des rip in
Operandos
A==B
Compara in (igualdad)
Value
A\=B
Compara in (desigualdad)
Value
{IsPro edure P }
Test si P es Pro edure
Pro edure
A<=B
Compara in (menor o igual)
Number o tomo
A<B
Compara in (menor)
Number o tomo
A>=B
Compara in (mayor o igual)
Number o tomo
A>B
Compara in (mayor)
Number o tomo
A+B
Suma
Number
A-B
Diferen ia
Number
A*B
Produ to
Number
A/B
Divisin
Number
Divisin entera
Integer
Mdulo (resto)
Integer
div B
A mod B
{ Arity R }
Aridad
Re ord
{ Label R }
Rtulo
Re ord
R.F
Sele in de ampo
Re ord
Figura 2.6: Operadores bsi os del lenguaje n leo de larativo.

La tabla de la gura 2.6 se listan los operadores bsi os del lenguaje n leo de larativo.
Se debe notar que las opera iones listadas en la gura 2.6 se muestran en nota in
inja, en realidad es un adorno sint ti o para ha er ms legibles las expresiones tal
omo se des ribi anteriormente.
2.3. Semnti a
La semnti a se denir en trminos de un modelo opera ional simple. Bsi amente se denir una mquina abstra ta ade uada para la evalua in de fun iones sobre
valores par iales.
El modelo permitir al programador razonar en forma simple sobre los programas
sobre su orre titud y omplejidad omputa ional. La mquina denida es una mquina de alto nivel la ual elimina los detalles en ontrados en otras mquinas abstra tas
omo registros del pro esador y dire iones de memoria.
32
Si bien la mquina es de alto nivel, su implementa in no tiene grandes di ultades.

Un programa en el lenguaje n leo de larativo es simplemente una senten ia. A
modo de ejemplo, dado el siguiente programa:
lo al A in
A = 20
{Browse A * 2}
end
Para dar una no in informal de su fun ionamiento, la mquina abstra ta es una

mquina pila en la ual ini ialmente se en uentra la senten ia ini ial. La mquina entra
en un i lo en el ual realiza los siguientes pasos:
1. Tomar (Pop) la senten ia
del tope de la pila.
Push, Pop, Bind y

opera iones sobre ambientes) segn la semnti a de s. Esto puede ha er que
2. Eje utar las opera iones bsi as de la mquina (opera in

se apilen nuevos elementos.
La eje u in naliza uando la pila queda va a.
2.3.1. La mquina abstra ta

La eje u in de un programa se dene en trminos de pasos de omputa iones sobre
la mquina abstra ta, lo ual es una se uen ia de estados de eje u in.
Deni in 2.3.1
La
memoria de asigna in ni a es un onjunto de variables
y valores. Las variables en la memoria forman una parti in de onjuntos que son
iguales pero no ligadas a valores y variables ligadas (a nmeros, registros o pro edimientos).
Por ejemplo, la memoria de asigna in ni a se denota omo
En este ejemplo, la variable
variables
x2
x3
x1
{x1 , x2 = x3 , x4 = 25}.
no est ligada (y no est igualada a ninguna otra), las
estn igualdas entre s y no estn ligadas, nalmente la variable
x4
est ligada al valor 25 (tipo integer ).
Deni in 2.3.2
Un
ambiente
es un mapping de identi adores a variables en
.
Denotaremos un ambiente
omo un onjunto de pares. Por ejemplo,
{X
x1 , Y x2 }.
Deni in 2.3.3
donde
<s>
Una
senten ia semnti a
es una senten ia y
es un par de la forma
(< s >, E),
es un ambiente.
Intuitivamente, una senten ia semnti a aso ia una senten ia on su ambiente de

eje u in ( onjunto de identi adores visibles por la senten ia).
Deni in 2.3.4
Un
estado de eje u in es un par de la forma (ST, ), donde ST
es una pila (sta k) de senten ias semnti as y
33
es una memoria de asigna in ni a.
Denotaremos una pila omo
[(< s >1 , E1 ), . . . , (< s >n , En )], donde el elemento de
mas a la izquierda orresponde al tope.
Deni in 2.3.5
Una
omputa in es una se uen ia de estados de eje u in omen-
zando desde el estado ini ial:
(ST0 , 0 ) (ST1 , 1 ) . . .
Cada transi in en una omputa in es un paso de omputa in.
2.3.2. Eje u in de un programa

Dado un programa o senten ia
< s >,
el estado de eje u in ini ial es denotado
omo
([(< s >, )], )

es de ir, la pila tiene la senten ia orrespondiente al programa on un ambiente
va o y la memoria est va a.
La mquina puede estar en tres estados de eje u in posibles:
Runnable (o a tiva), es de ir que puede realizar un prximo paso de eje u in.

Terminated uando la pila est va a.
Suspended
5
la pila no est va a pero no puede realizar un prximo paso de
eje u in . En el modelo se uen ial, si la mquina entra al estado
suspended,
el pro eso (programa en eje u in) quedar ongelado sin poder progresar.
2.3.3. Opera iones sobre ambientes

La mquina abstra ta tiene que realizar iertas opera iones sobre ambientes.
Adjun tion:
dene un nuevo ambiente en base de uno existente adi ionando

E + {X x} denota un nuevo ambiente E
un nuevo par (mapping). Ejemplo:

onstruido a partir de
Restri tion:
on un par adi ional.
dene un nuevo ambiente el ual es un sub onjunto de uno exis-
tente.
La nota in E |{x1 ,...,xn } denota un nuevo ambiente
y E (x) = E(x) pata todo x dom(E ).
E = dom(E) {x1 , . . . , xn }
Es de ir que el nuevo ambiente no ontiene otros identi adores ms que

Se utilizar la nota in
<X>
en el ambiente
E(< X >) para referirnos al
{x1 , . . . , xn }.
valor aso iado al identi ador
E.
5 Cuando se introduz a la no in de dataow variables y on urren ia se ver el porqu ste estado

tiene sentido.
34
2.3.4. Semnti a de las senten ias

En esta se in se dene la semnti a opera ional de la mquina abstra ta. Re ordar que la mquina eje uta el siguiente i lo:
state = running
while sta k not empty and state = running do
s := top sta k
pop
exe s
end
A oontinua in se dene la semnti a de ada senten ia del lenguaje, es de ir qu
deber implementar
exe .
(skip, E):
Pop sobre el sta k.
(s1 s2 , E):
( omposi in se uen ial).
1. Push
(s2 , E).
2. Push
(s1 , E).
lo al X in s end, E): (de lara in de variable).
1. Crear una nueva variable

2. Push
(X = Y, E):
1.
en la memoria
(s, E + {X x}).
(ligadura variable-variable).
Bind(E(X), E(Y )) en la memoria .

El operador Bind se expli ar en detalle mas abajo. Informalmente,
(uni a ) las variables X y Y para que E(X) == E(Y ).
(X = v, E):
( rea in de un valor).
aso ia
es un valor par ial de tipo Number, Re ord
o Pro edure.
1. Crear la representa in del valor
res de
en la memoria
Todos los identi ado-
tienen que referen iar a entidades determinadas por
E.
Ya se ha visto mo se rean valores numri os o registros, pero los pro edimientos (tambin llamados lausuras ) se rean de la siguiente manera:
Un valor
pro { $ y1 . . . yn
} s
end, de larado en el ambiente E , ha e que
se ree un estado de eje u in
pro { $ y1 . . . yn
donde
} s
end,CE)
CE = E |{z1 ,...,z1 }
{z1 , . . . , z1 }
son los identi adores que apare-
en libres en el pro edimiento, es de ir que no son uno de sus parmetros

formales o son variables lo ales denidos en
Las variables en
{z1 , . . . , z1 }
s.
se denominan referen ias externas del pro edi-
miento.
35
2. Ha er que
se reera a
en
if X then s1 else s2 end , E): ( ondi ional).
1. Si
no est ligada (E(X) es indeterminado),
2. Sino, si
state := Suspended.
est ligada a un valor que no es de tipo Boolean, disparar un
error (tipo invlido).

3. En otro aso, si
es
true, ha er Push (s1 ,E), sino Push (s2 ,E).
ase X of lit(f eat1 : X1 . . . f eatn : Xn ) then s1 else s2 end
, E): (pattern
mat hing).
1. Si
X no est ligada (E(X) es indeterminada), enton es state := Suspended.
2. Sino, si
Label(E(X)) = lit
Arity(E(X)) = [f eat1 . . . f eat1 ],
enton es
ha er
Push
(s1 , E + {X1 E(X).f eat1 , . . . , Xn E(X).f eatn })
3. en otro aso, Push
({X Y1 . . . Yn }, E):
1. Si
(s2 , E).
(apli a in pro edural).
X no est ligada (E(X) es indeterminada), enton es state := Suspended.
2. Sino, si no
IsP rocedure(E(X))
Arity(E(X) <> n,
disparar un error de
tipo.
3. Si
E(X)
pro { $ z1 . . . zn } s end,CE),
+ {z1 E(Y1 ), . . . zn E(Yn )})
tiene la forma (
Push (s,CE
ha er
2.3.5. Al an e (s ope)
A ontinua in se analizar el omportamiento del siguiente programa:
lo al X in
X=1
lo al
X in
X=2
s
s1
{Browse
end
s2 {Browse X}
X}
end
1. El estado de eje u in ini ial (ni o elemento en la pila) es
([(s, )], )
es de ir, la senten ia
on un ambiente va o y la memoria est va a.
2. La eje u in de la primer senten ia
([(s1 s2 , {X x1 )}], {x1 = 1})

36
lo al de s, obtenemos
3. La eje u in de la omposi in se uen ial obtenemos
([(s1 , {X x)}), (s2 , {X x1 })], {x1 = 1})

ada senten ia en la pila tiene su propio ambiente (el mismo en este aso).
4. La primer senten ia de
s1
es una senten ia
lo al y su eje u in deja
([(X = 2 {BrowseX}, {X x2 }), (s2 , {X x1 })], {x1 = 1, x2 })

esto es, la senten ia
ambiente
s1
on el ambiente
{X x2 }
y la senten ia
s2
on el
{X x1 }.
Se debe notar que el identi ador
se reere a dos variables distintas en ada
senten ia.
5. Despus de eje utar la senten ia
X =2
(binding) obtenemos
([({BrowseX}, {X x2 }), (s2 , {X x1 })], {x1 = 1, x2 = 2})

La invo a in al pro edimiento
{Browse X }
(en este aso 2, el valor de la variable
muestra el valor de la variable
x2 ).
6. Finalmente la mquina queda en la siguiente ongura in
([({BrowseX}, {X x1 })], {x1 = 1, x2 = 2})

el ual imprime el valor 1.
Luego de la eje u in de sta ltima senten ia la pila queda va a por lo que

naliza la eje u in del programa.
Lo anterior muestra que ela semnti a de la senten ia
lo al
introdu e un nuevo
ambiente y las senten ias ha en referen ia a las variables denidas en el ontexto de

su de lara in.
Esto se denomina
al an e estti o (stati s ope)
ya que el ambiente de refe-
ren ia in de ada senten ia se puede determinar sin ne esidad de eje utar el programa.
Lo anterior tiene un mayor impa to en la deni in de pro edimientos y fun iones,
ya que en una invo a in, el pro edimiento se eje uta en el ambiente de su de lara in.
Es de ir que ualquier referen ia no lo al en el uerpo del pro edimiento (variables
lo ales o parmetros formales), se reere a identi adores ligados a variables en su
ambiente de de lara in y no en el ambiente de su invo ante.
Esisten otros lenguajes que tienen
al an e dinmi o (dynami s ope)
en los
uales una senten ia o pro edimiento opera sobre el ambiente de su invo a in.
Lenguajes omo Clipper, S heme y Perl permiten tener ambos tipos de al an e.
El al an e estti o es el mas ade uado porque permite razonar sobre programas en
forma modular, es de ir sin tener en uenta sus posibles ontextos de invo a in.
Una ventaja que posee el al an e dinmi o es que es posible dar mayor exibilidad
en algunos asos omo por ejemplo en Clipper, el ual es un lenguaje orientado al
manejo de bases de datos y por ejemplo, la aperura de un ar hivo ha e que aparez an
37
automti amente variables mediante las uales se puede a eder a los valores de los
ampos de la la orriente de un ar hivo.
2.3.6. Tipado estti o vs dinmi o

Deni in 2.3.6
Un lenguaje es
seguro (type safe)
si no permite la eje u in de
una opera in sobre valores (operandos) invlidos.

El lenguaje n leo de larativo es seguro ya que tal omo se des ribi en la semnti a, antes de realizar una opera in se veri a que los datos sobre los que opera sean
del tipo esperado.
El pro eso de ver ar si los operandos de una opera in son del tipo orre to se
denomina
type he king.
Deni in 2.3.7
Un lenguaje es
estti amente tipado si es posible realizar el he-
queo de tipos durante la ompila in.

Si slo es posible ha erlo durante la eje u in se denomina
pado.
dinmi amente ti-
Por supuesto que un lenguaje que permita realizar hequeo estti o, deber expresar, expl ita o impl itamente el tipo de ada onstru in del lenguaje.
A modo de ejemplo, en Pas al todas las variables, onstantes parmetros y valores
retornados por fun iones deben de lararse (expl itamante) on su tipo orrespondiente.
De esta manera un ompilador Pas al tiene toda la informa in de los tipos de las
entidades que apare en en un programa por que puede realizar el hequeo de tipos en
durante la ompila in.
En los lenguajes fun ionales modernos omo Haskell, ML o Miranda no es ne esario
de larar los tipos de las expresiones denidas ya que le lenguaje puede inferirlos a partir
de los valores utilizados .

Estos lenguajes tienen un sistema de tipos y algoritmos de inferen ia de tipos muy
elaborado.
Cabe a larar que es posible realizar el hequeo de tipos estti amente en el lenguaje
n leo de larativo denido (an sin ambiar su sintaxis, mo?).
El tipado estti o tiene grandes ventajas ya que un programa que ompile, se podra
de ir que no tiene errores de tipos (est orre tamente tipado).
El tipado dinmi o, dete tar errores de tipos durante la eje u in, lo ual puede
ser un gran in onveniente.
La ventaja del tipado dinmi o es que permite mayor exibilidad para denir abstra iones polimr as
7 on mayor libertad, lo ual da un mayor poder expresivo
(relativo).
6 No es posible realizarlo en forma automti a slo en algunos asos espe iales.

7 Una opera in es polimr a si a epta argumentos de diferentes tipos en diferentes
38
invo a iones.
En los aptulos siguientes se analizar en detalle los diferentes tipos de polimorsmo que podemos en ontrar en los diferentes paradigmas.
2.3.7. Manejo de la memoria

Como se puede apre iar en la eje u in del programa de ejemplo de la se in 2.3.5,
el lenguaje n leo tiene senten ias de rea in de valores pero no para su destru in.
Las variables y valores ontinan estando en la memoria an uando ya no exista
la posibilidad que el programa haga una referen ia a ellas (porque no existen en el
ambiente identi adores que las referen ien).
Si bien esto no es un in onveniente, ya que por ahora slo nos interesa denir su
semnti a formal, una implementa in real debera tomar esto en uenta.
Una implementa in debera in luir un me anismo para podel eliminar de la memoria (para que en sta no se extinga su apa idad de alma enamiento) aquellas variables
y valores que ya no podrn ser referen iadas por el programa.
Este me anismo se ono e generalmente omo re ole in de basura (garbage

olle tion). El re ole tor de basura realiza un barrido de la pila y la memoria para
dete tar y eliminar variables y valores inal anzables.
En el aptulo de manejo de la memoria se ver en mas detalle el fun ionamiento
de un re ole tor de basura.
2.3.8. Uni a in (operador '=')

El operador
produ e aso ia iones (o bindings) en la memoria de variables y
valores (value store ).
Deni in 2.3.8
Un
trmino es un tomo, un nmero, un registro o un identi a-
dor.
Deni in 2.3.9
Una
que toma una variable
sustitu in de
X,
un trmino
la ual es obtenida a partir de

de
por
una variable por un trmino es una fun in

E y retorna una expresin E
y una expresin
en la ual se han reemplazado todas las o urren ias
T.
Deni in 2.3.10
posi in de
Se di e que dos expresiones
sustitu iones tal
que apli ada
E1
E1 y E2 uni an si existe una omE2 , las expresiones resultantes son
iguales (sint ti amente).

Es posible ver a la uni a in omo una opera in que produ e informa in adi ional en la memoria
El operador
= tiene las siguientes propiedades:
1. Simtri o : por ejemplo
age:25) = X.
X = person(name:X1 age:25) es igual que person(name:X1
39
2. Opera sobre valores par iales : por ejemplo, (si X1 y X2 no estn ligadas)
person(name:X1 age:25) = person(name:George age:X2

produ e los bindings
X1 George
X2 25.
3. Puede no ausar ambios : en el aso que ambos valores (par iales o no) sean
iguales (uniquen).
4. Puede ausar error : en el aso que ambos valores sean in ompatibles.
Por ejemplo:
person(name:X1 age:25)=person(name:X1 age:26)
5. Puede rear estru turas li as : omo en el siguiente aso:
L=node(value:X rest:L)
6. Puede ligar estru turas li as : es posible uni ar las siguientes expresiones:
X=f(a:X b:_) y Y=f(a:_ b:Y)

(b:_) signi a que el ampo B no est ligado (unbound).
X=Y rea
X=f(a:X b:X).
La senten ia
omo
una estru tura on dos i los, la ual puede expresarse
La gura 2.7 muestra su representa in en la memoria.
X=f(a:X b:_)
X
X=Y
Y=f(a:_ b:Y)
Y
X=f(a:X b:X)
Figura 2.7: Ejemplo de estru turas li as.
2.3.9. El algoritmo de uni a in

Para dar una deni in pre isa de la uni a in, se denir la opera in unify(x,y)
que uni a dos valores par iales
en la memoria
Es ne esario denir algunos on eptos previos.

Tal omo se vio anteriormente, la memoria de asigna in ni a
en los siguientes onjuntos:
40
, est parti ionada
Conjuntos de variables no ligadas iguales (han sido igualadas por variable-variable

binding). Estos onjuntos se denominan onjuntos de equivalen ia.
Variables ligadas a valores de tipo Number, Re ord o Pro edure (variables determinadas).
Un ejemplo de la memoria parti ionada es:
{x1 = f oo(a : x2 ), x2 = 25, x3 = x4 =
x5 , x6 , x7 = x8 }.
El algoritmo de uni a in se basa en las opera iones primitivas bind y merge, las
uales operan sobre la memoria
1.
bind(ES, v):
liga las variables en el onjunto de equivalen ia
Por ejemplo,
bind({x7 , x8 }, f oo(a : x2 ))
ES
on el valor
v.
modi a la memoria dada en el ejemplo
anterior resultando la memoria
{x1 = f oo(a : x2 ), x2 = 25, x3 = x4 = x5 , x6 , x7 = f oo(a : x2 ), x8 = f oo(a : x2 )}.

2.
merge(ES1 , ES2 ): ha e que en la memoria los onjuntos

ES2 se fusionen (unin) en un onjunto de equivalen ia.
Nuevamente on la memoria de ejemplo de arriba,
modi a la memoria
de equivalen ia
ES1
merge({x3 = x4 = x5 }, {x6 })
omo
{x1 = f oo(a : x2 ), x2 = 25, x3 = x4 = x5 = x6 , x7 = x8 }.

unif y (x, y, L)
1. Si
(x, y) W L
2. Si
x ESx
y ESy ,
3. Si
x ESx
es determinada, ha er
bind(ESx , y).
4. Si
y ESy
es determinada, ha er
bind(ESy , x).
(y, x) W L,
terminar.
enton es ha er
merge(ESx , ESy ).
x est ligada a l(l1 : x1 . . . ln : xn ) e y est ligada a l (l1 : y1 . . . lm

: ym ),
l 6= l o {l1 , . . . , ln } 6= {l1 , . . . , lm }, disparar un error.
5. Si
x est ligada a l(l1 : x1 . . . ln : xn ) e y est ligada a l(l1 : y1 . . . ln : yn ),

unif y (xi , yi , W L + {(x, y)}), para todo i, 1 i n.
6. Si
on
ha er
unif y(x, y) = unif y (x, y, )

Figura 2.8: El algoritmo de uni a in.
La gura 2.8 muestra el algoritmo de uni a in. Se debe notar que el algoritmo
fun iona an on estru turas li as ya que en
WL
se re uerda la lista de variables
ya uni adas.
Esto impide que el algoritmo entre en un i lo innito, ya que a lo sumo se invo a
unif y (x, y) por ada par de variables x e y . Como la antidad
a lo sumo una vez a
de variables en la memoria es nita, el algoritmo termina.
41
2.3.10. Igualdad (operador ==)

8
La opera in ==, tambin llamada entailment he k , es una fun in lgi a (retorna
true o false) que hequea si x e y
son iguales o no.
El operador sigue el siguiente algoritmo:

1. Retorna
true
si los grafos uyos vrti es parte de
son iguales, es de ir,
tienen la misma estru tura.

2. Retorna
false si los grafos uyos vrti es parte de x e y son diferentes, o sea que
no tienen la misma estru tura.

3. Pone la mquina abstra ta en modo
Suspended uando en uentra algn om-
ponente una de estru turas que no est ligado y en la otra s.

Este tipo de igualdad (o equivalen ia) se ono e omo
tural.
emphequivalen ia estru -
Tiene omoventaja que es posible omparar estru turas omplejas pero el algoritmo
requiere tiempo lineal sobre el tamao de la estru tura. El algoritmo deber tener
uidado on las estru turas li as, pero el problema ha sido ampliamente estudiado
en el ampo de los algoritmos sobre grafos.
Otros lenguajes realizan slo ompara iones sobre valores de los tipos bsi os no
estru turados, omo es omn en lenguajes imperativos omo Pas al o C.
La igualdad de valores estru turados generalmente la tiene que denir el programador.
2.4. Ejer i ios

1. Denir un pro edimiento que al ule el fa torial de su argumento en el lenguaje
kernel.
2. Mostrar a salida del siguiente programa:
lo al X in
lo al Y in
lo al Z in
X = person(name:"George" age:Y)
Z = 26
Z = Y
{Browse Y}
end
end
{Browse X}
end
8 El trmino entailment viene de la lgi a, ya que puede verse omo |= (x = y) (desde sigma
puede inferirse que x = y.
42
Nota: el pro edimiento {Browse Arg} muestra el valor aso iado a Arg.
3. Eje utar paso a paso el siguiente programa:
lo al X in
lo al Y in
X = person(name:"George" age:25)
Y = person(name:"George" age:26)
X = Y
end
{Browse Y}
end
4. Dado el siguiente programa, mostrar su eje u in paso a paso segn la mquina
abstra ta denida.
lo al X in
X = 1
lo al P in
P = pro {\$}
{Browse X}
end
lo al X in
X = 2
{P}
end
end
end
5. El programa del ejer i io anterior muestra que el al an e (s ope) es estti o, es
de ir un pro edimiento se evala en el ambiente de su deni in.
Modi ar la semnti a del lenguaje kernel para que tenga al an e dinmi o, es

de ir, una invo a in a un pro edimiento se evala en el ambiente de su invo ante.
Eje utar el programa on la nueva semnti a para veri ar que la salida del
programa sera
6. Una expresin es una abrevia in sint ti a de una se uen ia de opera iones que
arrojan un valor. Suponiendo que extendemos la sintaxis de nuestro lenguaje
para permitir expresiones en las opera iones de binding y en la ondi in de la
senten ia
if.
A ontinua in se muestra un ejemplo, asumiendo que tambin se ha extendido

la senten ia
lo al para permitir la introdu in de una lista de variables.

43
lo al X Y in
X = 1
Y = 2 + X
if X > Y then
{Browse X}
else
{Browse Y}
end
end
Tradu ir el programa al lenguaje kernel.
7. Mostrar que en el siguiente programa re ursivo a la ola, el tamao de la pila se
mantiene limitada o a otada.
pro {Loop5 I}
lo al C in
C = I == 5
if C then skip
else
lo al J in
J = I + 5
{Loop5 J}
end
end
end
Ayuda: eje utar al menos dos invo a iones re ursivas.
44
Captulo 3
lenguajes fun ionales

Como ya se men ion en el aptulo anterior, el modelo de larativo omprende
dos submodelos: la programa in fun ional y la programa in lgi a. En este aptulo
se desarrollarn en mayor detalle los on eptos subya entes a la programa in fun ional y en parti ular a las ara tersti as y on eptos propios de los lenguajes fun ionales.
En este aptulo se des riben las ara tersti as propias de la programa in fun ional, sus modelos de omputa in fundamentales y nalmente se des riben algunas
ara tersti as de algunos lenguajes fun ionales modernos omo Haskell y ML.
3.1. Programa in fun ional

La programa in fun ional tiene sus orgenes on el desarrollo de LISP, desarrollado por John M Carty a nales de 1950. Si bien LISP no es un lenguaje fun ional puro,
tiene mu hos on eptos utilizados en lenguajes fun ionales modernos.
Los modelos abstra tos de omputa in (o fundamentos teri os) que pueden tomarse omo la maquinaria ne esaria para la implementa in de lenguajes fun ionales
tienen sus ra es en el l ulo lambda y en la lgi a ombinatoria.
Lenguajes omo S heme y Dylan son derivados de LISP. En 1977, John Ba kus
publi el memorable art ulo Can Programming Be Liberated From the Von Newmann
Style?, por el ual se le otorg el premio Turing Award Le ture. En ese art ulo Ba kus
propone el lenguaje FP (fun tion-level programming language ), el ual introdu e los
prin ipales on eptos de la programa in fun ional moderna.
La programa in fun ional tiene sus propias ara tersti as y on eptos, que se
des riben a ontinua in.
1 John Ba kus, entre otras osas, desarroll FORTRAN y fue el reador de la BNF (Ba kus Naur
Form).
45
3.2. Cara tersti as prin ipales

Algunos on eptos son propios de la programa in fun ional y a menudo ausentes
en lenguajes imperativos. Sin embargo, el estudio de estos on eptos son tiles para el
programador an uando utili e lenguajes imperativos (y orientados a objetos) ya que
mu hos lenguajes imperativos modernos introdu en algunos me anismos para poder
implementar algunas de las ara tersti as propias de los lenguajes fun ionales.
Algunos de los on eptos que ara terizan a la programa in fun ional son:
Fun iones (o expresiones) puras:
no tienen estado propio (memoria) y no
tienen efe tos olaterales. Es de ir que tienen las siguientes propiedades (algunas
de las uales pueden ser usadas por el intrprete o ompilador para optimizar
digo):
Si el resultado de una expresin no se utiliza, puede des artarse en forma

segura (no afe tar a las otras fun iones o expresiones.
Cada vez que se llame a una fun in on los mismos argumentos, el resultado
ser el mismo. Esto se ono e omo transparen ia referen ial.
No existe dependen ia de datos en las fun iones puras, lo que dos o ms

fun iones (que no dependan entre ellas) pueden ser evaluadas on urrentemente sin ninguna ne esidad de sin roniza in.
Se puede utilizar ualquier orden o estrategia de evalua in.
Re ursin : A diferen ia de los lenguajes imperativos, la itera in se onsigue

por medio de re ursin, es de ir, una fun in puede invo arse a s misma. La
re ursin puede requerir espa io en la pila de eje u in, aunque omo ya se vio
anteriormente, una fun in (o pro edimiento) re ursivo a la ola (tail re ursion)
puede implementarse omo una itera in (while) en un lenguaje imperativo.
Fun iones de alto orden : Una fun in es de alto orden uando puede tomar
fun iones omo argumentos o retornar fun iones omo resultado. Las fun iones
de alto orden son naturales en la programa in fun ional y son la base de la
t ni a de programa in ono ida omo programa in genri a.
Orden de evalua in : En general se pueden utilizar dos estrategias de evalua in

de las expresiones: estri ta o ansiosa (eager) y no estri ta (normal).
A modo de ejemplo del estilo de la programa in fun ional se muestra el problema
de al ular el produ to interior de dos ve tores
de dimensin
N.
Al estilo imperativo, se podr es ribir un fragmento de programa de la forma:
...
p := 0;
for i := 1 to N do
p := p + a[i * b[i
46
El resultado quedar en la variable
p.
2
Una solu in al estilo fun ional podra es ribirse omo (al estilo de FP):
InnerP roduct (Insert+) (ApplyT oAll) T ranspose

La deni in anterior di e que el produ to entre dos ve tores representados de la
forma
<< a1 , . . . , an >, < b1 , . . . , bn >>
(una matriz de dos las, representada omo
una lista de listas) puede ser evaluada mediante la omposi in de tres pasos:
1. Obtener la transpuesta de matriz de entrada.
2. Apli ar el operador
a ada elemento (pares) de la lista obtenida.
3. Apli ar el operador
(re ursivamente a los elementos de la lista obtenida).
Un ejemplo de evalua in de la fun in
1, 2, 3 >, < 6, 5, 4 >>
InnerP roduct
apli ada al argumento
<<
sera:
1. La apli a in de Transpose retorna

2. La apli a in de ApplyToAll
<< 1, 6 >, < 2, 5 >, < 3, 4 >>.
< :< 1, 6 >, :< 2, 5 >, :< 3, 4 >>,

< 6, 10, 12 >
retorna
uya evalua in arrojara el valor
< 6, 10, 12 >, retorna + :< 6, + :< 10, 12 >>,

+ :< 6, 22 > y la evalua in nal sera el valor 28.
3. La apli a in de Insert + a
evalua in retornara
uya
3.3. Ventajas y desventajas on respe to a la programa in imperativa

De un anlisis inmediato del programa imperativo, podemos ha er las siguientes
observa iones:
Sus senten ias operan sobre un estado po o visible.
No es modular (jerrqui o), salvo por la parte dere ha de la asigna in (expresin). Es de ir, no onstruye entidades desde otras mas simples (lo ual su ede
generalmente on grandes programas).
Es dinmi o y repetitivo. Se debe eje utar mentalmente para omprender qu
ha e.
Computa un valor a la vez en ada repeti in (mediante la asigna in) y por
modi a in (de la variable
i).
Fun iona slo para ve tores de longitud
N.
2 Extraido del art ulo Can Programming Be Liberated From the Von Newmann Style? de John
Ba kus, disponible en http://www.stanford.edu/ lass/ s242/readings/ba kus.pdf
47
Sus argumentos estn nombrados. Si se desea mayor generalidad (reusabilidad)

se deber denir una abstra in (pro edimiento o fun in) parametrizada, lo
ual requiere de otros me anismos omplejos.
Las opera iones bsi as estn dispersas por todo el programa (senten ia
for, ::=,
. . . ).
El programa fun ional tiene las siguientes propiedades:
Opera slo sobre sus argumentos.

Es jerrqui o. La fun in se dene en trminos de otras.
Es estti a y no repetitiva.
Opera sobre valores on eptuales, no en pequeos pasos.
Es ompletamente general (opera sobre dos ve tores ualesquiera).
No nombra a sus argumentos.
Si bien del anlisis anterior es posible ver las ventajas de la programa in fun ional
sobre la imperativa, es justo nombrar algunos problemas en los uales la no in de
estado es importante y natural para su solu in.
El modelado de la entrada-salida es natural si se piensa en trminos de estado.

Algunos sistemas (ej: sistemas rea tivos) requieren estado. Ejemplos: sistemas
operativos, sistemas de ontrol, et .
Sistemas uya informa in no se omputa sino que se mantiene (alma ena) en
memoria y es modi ada o re uperada por algunas opera iones (ej: ole iones,
uentas ban arias, et ).
Es posible modelar estado en la programa in fun ional utilizando mnadas. En la

se in 3.6.2 se ha e una breve introdu in a mnadas.
3.4. Fundamentos teri os

Los fundamentos o teora subya ente de la programa in fun ional tiene sus ra es
en el l ulo lambda, el ual ha sido utilizado no slo para dar semnti a de lenguajes
fun ionales sino tambin en algunos fragmentos de lenguajes imperativos y orientados
a objetos.
48
3.4.1. Cl ulo lambda

El l ulo lambda (
calculus),
desarrollado por Alonzo Chur h y Stephen Cole
Kleen en 1930, es un sistema formal diseado para investigar las deni iones de fun iones y sus apli a iones.
El l ulo lambda se puede ver omo un lenguaje minimalista de programa in,
sobre el ual se dene un modelo de omputa in, el ual tiene el mismo poder omputa ional de otros lenguajes de programa in (turing omputable).
Adems de sus apli a iones en ien ias de la omputa in tiene un rol fundamental
en el rea de fundamentos de la matemti a, gra ias a la orresponden ia CurryHoward.
En esta se in se analizar el l ulo lambda no tipado. Mu has de sus apli a iones utilizan una de sus extensiones ono ida omo l ulo lambda tipado.
Informalmente, en el l ulo lambda ada expresin es una fun in unaria. Es de ir
que ada fun in toma un argumento y retorna un valor.
Deni in 3.4.1
Una expresin en el l ulo lambda se puede denir indu tivamente
omo:
1. Una variable (denotadas omo
2. Abstra in lambda: si
tambin lo es
3. Apli a in: si
x, y, . . .)
es una expresin lambda.
es una variable y
es una expresin lambda, enton es
(x.M ).
M, N
son expresiones lambda, enton es tambin lo es
(M N ).
Para evitar el uso ex esivo de parntesis, omnmente se apli an las siguientes

onven iones:
Los parntesis exteriores se omiten, esto es,
MN
en lugar de
La apli a in se asume aso iativa a izquierda. Esto es,
MNP
(M N ).
signi a
(M N ) P .
El uerpo de una abstra in se extiende todo lo posible a la dere ha:

signi a
(xM N )
y no
Una se uen ia de abstra iones se pueden ontraer:

omo
xy.N
El onjunto de variables libres de una expresin lambda
F V (M ),
F V (x) = {x}
se dene re ursivamente omo:

(x es una variable).
F V (x.M ) = F V (M ) {x}.
3 Rela in
se puede abreviar
xy.N .
Deni in 3.4.2
tada omo
xM N
(xM )N .
dire ta entre programas y desmostra iones matemti as.

49
M,
deno-
F V (M N ) = F V (M ) F V (N ).
Una variable no libre en una expresin
Deni in 3.4.3
Una expresin
on
se di e que est ligada.
F V (M ) =
se denomina errada, tambin
ono idos omo ombiadores.
3.4.1.1. Redu in
La rela in de redu in dene los pasos de omputa in que se pueden apli ar a
una expresin lambda.
Conversin alpha: permite renombrar a las variables ligadas. Cabe a larar que
la apli a in en una expresin de esta regla puede ambiar su signi ado. Por
ejemplo, si en la expresin
Redu in beta
xy.x
se reemplaza
(apli a in de fun in):
por y, se obtiene
yy.y .
((x.E1 )E2 es E1 [x E2 ], donde

E2 por ada variable libre x en
E1 [x E2 ]
signi a el reemplazo simultneo de
la expresin
E1 .
Esto se denomina sustitu in.
Conversin eta (extensionalidad): dos fun iones son iguales si dan los mismos
resultados en ada uno de sus posibles argumentos. Por ejemplo,
onvertir a
f,
siempre que
no aparez a libre en
x.f x
puede
f.
Esta onversin no es siempre onveniente uando las expresiones lambda son interpretadas omo programas (la evalua in de
la evalua in de
x.f x puede terminar, an uando
no).
3.4.1.2. Computa in y l ulo lambda

A ontinua in se mostrar que es posible denir valores y fun iones bsi as lo que
muestra que el l ulo lambda tiene la misma expresividad que ualquier lenguaje de
programa in.
Numerales de Chur h y aritmti a:

0 f x.x
1 f x.f x
2 f x.f (f x)
...
El numeral de Chur h
n es una fun in que toma una fun in f omo argumento

f (f ompuesta onsigo misma n ve es).
y retorna la ensima omposi in de
SU CC n f x.f (n f x)
P LU S m n f x.n f (m f x) o P LU S m n.m SU CC n.
Multipli a in: M U LT m n f.m(n f ) o P LU S m n.m(P LU S n)0
Fun in su esor:
Suma:
50
La fun in prede esor (P REDn
= n1
P RED0 = 0)
es mas di ulto-
sa para des ribir. La siguiente deni in se puede validar por indu in: sea
T = g h.h(g f ), enton es T n (ux) = (h.h(f n1 (x))), para n > 0.
P RED n f x.n(g h.h(g f ))(u.x)(u.u)

Mas abajo de dene
P RED
de dos maneras alternativas adi ionales usando
ondi ionales y pares.
Operadores lgi os
F ALSE t f.f (notar
T RU E t f.t
AN D p q.p q p
OR p q.p p q
N OT pab.pba
que es igual al ero).
Predi ados (fun iones que retornan valores lgi os):

ISZERO n.n(x.F ALSE)T RU E
LEQ mn.ISZERO(SU Bmn) (donde SU Bmn
Es posible redefnir
P RED
es
m n)
usando predi ados:
P RED n.n(g k.ISZERO(g 1)k P LU S(g k)1)(v,0)0
Pares: (f
representara el onstru tor del par)
P AIR xyf.f x y
F ST p.pT RU E
SN D p.pF ALSE
Tambin es posible redenir
P RED
usando pares:
P RED n.F IRST (n SHIF T AN DIN C(P AIR 0 0),
donde
SHIF T AN DIN C x.P AIR(SECON D x)(SU CC(SECON D x))

(SHIF T AN DIN CP AIR(m
n) = P AIR(n n + 1))
Re ursin
El ombinador
Y g.(x.g(xx))(x.g(xx))
y se ono e omo el operador de punto jo ya que
(expande a
Yg
es un punto jo de
g(Y g)).
F ACT f n.(1, if n = 0andn.f (n,1), if n > 0),

F ACT (Y F ACT ) n, es posible omputar el fa torial de n.
Por ejemplo, sea
El on epto de omputabilidad se puede denir de la siguiente forma:
51
si se apli a
Deni in 3.4.4
F : N N es omputable si y slo si existe una

x, y N, F (x) = y si y slo si f a = b,
de Chur h orrespondientes a x e y , respe tivamente.
Una fun in
expresin lambda tal que para ada par de

donde
son los numerales
No existe un algoritmo (una fun in omputable) que tome dos expresiones lambda
y retorne
T RU E
F ALSE
en base si las expresiones son equivalentes. Este resultado
se ono e omo la tesis de Chur h.

Mu hos lenguajes de programa in permiten denir fun iones lambda (python,
. . . ) las uales pueden pasarse omo argumentos a otras fun iones (o pro edimientos).
Otros lenguajes permiten implementar alto orden usando punteros o referen ias (ej: C,
C++). Algunos lenguajes orientados a objetos permiten denir objetos que representan
fun iones, on lo ual se logra alto orden (ej: C++, Smalltalk, Ruby, Eiel).
Algunos me anismos de pasajes de parmetros en lenguajes imperativos permiten
implementar alto orden (ej: pasaje por nombre y las referen ias o punteros a fun iones).
3.4.1.3. Estrategias de redu in

En esta se in se analizan diferentes estrategias de apli a in de las reglas de
redu in. Las estrategias se ono en tambin omo rdenes de evalua in.
Deni in 3.4.5
Una expresin que no puede ser redu ida se denomina forma nor-
mal.
Deni in 3.4.6
Un
redex (expresion redu ible) es o un redex o un redex.
Una expresin
es un
redex
si
tiene la forma
((x.M ) N ).
Una expresin
es un
redex
si
tiene la forma
x.M x
en
no est libre
M.
La expresin a la ual se redu e por apli a in de una regla se denomina

Los redu tos de los redexes son
M [x N ]
M,
redu to.
respe tivamente.
A ontinua in se des riben las diferentes estrategias posibles:
Full beta redu tion: ualquier redex puede redu irse en ada paso.
Orden apli ativo: en ada paso se elige el redex ms interno y ms a la dere ha.
Intituivamente, esto signi a que los argumentos siempre se redu en antes que
la apli a in de la fun in, lo que impli a que las fun iones siempre operan sobre
formas normales.
Mu hos lenguajes de programa in utilizan esta estrategia de evalua in (C,

C++, Java, ML, LISP, . . . ). Esta estrategia se ono en tambin omo estri ta.
Orden normal:
en ada paso se elige el redex de ms a la izquierda y ms
externo. Los argumentos se sustituyen dentro del uerpo de una abstra in

antes que sean redu idos.
52
Por nombre ( all-by-name): igual que on orden normal, pero no se realizan

redu iones dentro de las abstra iones.
Por ejemplo, la expresin
x.(x.x)x, ya est en
(x.x)x
forma nomal usando esta estra-
tegia, aunque ontiene el redex
Por valor ( all-by-value): en ada paso se redu e el redex ms externo. Esto

impli a que un redex puede ser redu ido despus que su parte dere ha (right
hand side) se ha redu ido a un valor (variable o abstra in lambda).
Por ne esidad ( all-by-need): igual que en orden normal, pero aquellas apli a iones que podran generar trminos dupli ados en lugar de nombres de argumentos, se redu en slo uando sean ne esitados. Esta estrategia se ono e
generalmente omo evalua in lazy y en la pr ti a omnmente se implementa
usando punteros (el ual representa el nombre ) y el redex se representa on una
estru tura de datos (usualmente un rbol o un DAG).
El orden apli ativo no es una estrategia normalizante, es de ir que no siempre
E1 = (x.xx x.xx),
E1 . Esto signi a que E
no tiene forma normal (bajo ninguna estrategia). La expresin E2 = (x y.x)(x.x)E1 ,
usando orden apli ativo, se debe apli ar en E1 primero, pero omo E1 no tiene forma
normal, el orden apli ativo falla para en ontrar una forma nomrmal de E2 .
permite redu ir a formas normales. Por ejemplo, la expresin

ontiene slo un redex (la expresin ompleta) y su redu to es
4 En el ejemplo
Con orden normal siempre es posible redu ir a una forma normal.

anterior, utilizando orden normal,
E2
redu e a
I = x.x.
Una de las ventajas del orden apli ativo sobre el orden normal, es que el primero no produ e omputa iones inne esarias si se utilizan todos los argumentos en las
abstra iones, porque nun a sustituye argumentos onteniendo redexes (porque ya han
sido redu idos previamente).
3.4.2. Lgi a ombinatoria

La lgi a ombinatoria fue propuesta por Moses S hnnkel y Haskell Curry on
el objetivo de eliminar variables uanti adores en la lgi a matemti a. La primer
propuesta se debe a Moses S hnnkel en 1924. Curry redes ubri los ombinadores en
1927. Entre 1960 y 1970, se omienza a utilizar en las ien ias de la omputa in omo
un modelo simplista de omputa in y en la implementa in de lenguajes fun ionales.
Deni in 3.4.7
Un
ombinador es una fun in de alto orden, yua deni in slo
usa apli a in de fun iones y otros ombinadores.

As omo el l ulo lambda tiene su sintaxis, tambin lo tienen los ombinadores.
Deni in 3.4.8
4 De
Un
termino ombinatorio puede denirse indu tivamente omo:
all el nombre de la estrategia.

53
x:
donde
P:
donde
(E1 E2 ):
es una variable.
es una fun in primitiva.
apli a in de
E1
E2 .
Las fun iones primitivas son ombinadores, es de ir que no tiene variables libres.
La deni in de ada ombinador primitivo dene su regla de redu in.
Ejemplos de ombinadores primitivos:
(I x) = x
: (identidad).
((K x) y) = x
: (genera fun iones onstantes)
(S x y z) = (x z (y z))
dentro del ontexto de
: versin generalizada de apli a in (x es apli ada a
z ).
I
De debe notar que el ombinador
puede obtenerse de
K,
dado que
I =
((S S K)x).
Y, el ual ya fue denido en la se in anterior.

El ombinador Y , puede denirse en trminos de los ombinadores primitivos SKI:
Otro importante ombinador es el
Y = S(K(SII))(S(S(KS)K)(K(SII)))
El siguiente teorema muestra que es posible denir ada expresn lambda en ombinadores, utilizando los ombinadores primitivos
Teorema 3.4.1
SKI.
Cada expresin lambda tiene su equivalente trmino ombinatorio en
trminos de los ombinadores primitivos
SKI.
Demostra in ( onstru tiva): se denir una fun in de tradu in

nes lambda a ombinadores.
1.
T [x] x.
2.
T [(E1 E2 )] (T [E1 ] T [E2 ])
3.
T [x.E] (KT [E])
4.
T [x.x I
5.
T [x.y.E] T [x.T [y.E]]
6.
T [x.(E1 E2 )] (S T [x.E1 ] T [x.E2 ]
, si
no est libre en
, si
54
E.
es libre en
E.
de expresio-
Dado que ada trmino lambda puede ser tradu ido a un ombinador
junto de ombinadores primitivos
SK se denomina ompleto.
SKI, el on-
Los ombinadores son importantes ya que es posible la eje u in (interpreta in)

de fun iones representadas omo ombinadores por medio de una t ni a algortmi a
ono ida omo redu in de grafos. La idea se basa en que las expresiones pueden
representarse omo grafos. La deni in de ada ombinador espe i a un paso de
omputa in (redu in de un grafo a otro), por lo que la evalua in de expresiones
puede denirse por opera iones (fun iones) sobre grafos.
En su art ulo original, S hnnkel, propuso dos ombinadores ad ionales:
(C a b c) = (a c b)
(B a b c) = (a (b c))
Estos ombinadores son muy tiles para realizar una tradu in ms dire ta desde
el l ulo de predi ados y el l ulo lambda a la li a de ombinadores.
3.5. LISP
LISP (LISt Pro essing)fue inventado por John M Carty en 1958 en el MIT. La sintaxis del lenguaje se basa en la no in de S-expresiones (symboli expressions), omo
por ejemplo ( ar( ons A B)).
El lenguaje tiene una sintaxis sorprendentemente simple, tipado dinmi o y manejo

de la memoria automti o ya que in luye un re ole tor de basura (garbage olle tor).
LISP generalmente es interpretado y tiene varios lenguajes derivados omo CommonLISP y Sheme.
3.5.1. Sintaxis
LISP es un lenguaje orientado a expresiones. La evalua in de una expresin arroja
un valor (o lista de valores). Los valores pueden ser bsi os (ej: nmeros, ara teres y
tomos) o estru turados (listas).
Los tipos de datos en LISP pueden ser dos: tomos o listas.
Un tomo es un identi ador (smbolo) o una onstante numri a o ara ter. Las
expresiones se es riben omo listas en forma preja.
Una lista en LISP es una lista simplemente enlazada. Cada elda de una lista se
denomina un
ons el ual
ar)
tiene dos omponentes: la abeza (
dr).7
y el resto (
5 Slo se ne esitaran denir las fun iones de redu in para ada ombinador primitivo.
6 Lo ual evala a A, la abeza ( ar ) de la lista [a,b ( ons es el onstru tor de listas.
7 Los nombres ar y dr se deben a ontents of address register y ontents of de rement
register,
respe tivamente y tienen rela in dire ta a la primera implementa in de LISP en la IBM 704.
55
Por ejemplo, la fun in list retorna sus argumentos omo una lista, as la expresin
(list '1 'foo)
retorna la lista
(1 foo).
El apstrofe (quote) que pre ede los
argumentos es un operador espe ial que previene su evala in.

La expresin predenida
(if E1 E2 )
que representa la lista va a), sino retorna
retorna
E1
si
evala a
nil
(un tomo
E2 .
Las s-expresiones representan listas.
expresiones lambda, es de ir fun iones annimas.

lambda es (lambda args body), donde args es la lista de
LISP soporta la deni in de

La forma de una deni in
argumentos y
body es la
lista que representa la deni in de la fun in.
A modo de ejemplo, la expresin
(lambda (n) (+ n 1)) evala a una fun in que,
uando sea apli ada, evaluar al su esor del argumento dado.
3.5.2. Semnti a
LISP evala las expresiones a menos que estn pre edidas por el operador
quote
('). La evalua in naliza uando una expresin es un valor bsi o (nmero, tomo o
lista que evala a s misma). Cada elemento de una lista que est ligado a una deni in de una fun in podr ser evaluada, sino es onsiderada un valor (evala a s
mismo).
El orden de evalua in utilizado por LISP es estri to, espe amente orden apli ativo.
El intrprete de LISP (fun in
eval) implementa un i lo de la forma leer, evaluar,
mostrar, es de ir que se lee una expresin, se evala y muestra el resultado.

La fun in
defun dene una nueva fun in en una sesin la ual puede ser invo ada
posteriormente. A ontinua in se muestra la deni in de la fun in fa torial.
(defun fa torial (n)

(if (<= n 1) 1 (* n (fa torial (- n 1))))
)
Ahora es posible evaluar el fa torial de 5 omo:
(fa torial 5).
El al an e (s ope o lausuras) en LISP original era dinmi o. Algunos lenguajes

derivados de LISP omo CommonLisp o Sheme tienen al an e estti o.
Otras implementa iones, omo los diale tos de LISP que soportan apli a iones
omo Ema s o AutoCAD mantienen el al an e dinmi o.
3.5.3. Estado
LISP no es un lenguaje fun ional puro ya que permite ompartir y modi ar estru turas denidas.
Por ejemplo, la fun in
setf, permite
56
ligar (bind) una referen ia a un valor.
Si se ha e
el valor
(setf s ( ons 'a 'b)) y luego (setf ( ar s) 1), al evaluar s arroja
(1.b).8
3.5.4. Apli a iones

El lenguaje LISP y sus derivados se utilizan ampliamente en ampos de inteligan ia
arti ial, omo pro esamiento simbli a, representa in de ono imiento o otros. Adems, la simpli idad de su implementa in lo ha e ade uado omo lenguaje de s ripting,
los uales generalmente algunas apli a iones in orporan para permitir realizar extensiones (plugins), omo Ema s y AutoCAD.
3.6. Lenguajes fun ionales modernos

Los lenguajes fun ionales han evolu ionado prin ipalmente en sus sistemas de tipos,
on polimorsmo paramtri o, inferen ia de tipos, tipos de datos algebrai os, deni iones por patrones (pattern mat hing), listas por omprensin y manejo de ex ep iones,
entre otras ara tersti as.
En esta se in de analizan dos lenguajes fun ionales modernos ampliamente utilizados. El primero (ML) no es un lenguaje fun ional puro, ya que permite denir y
manipular estado, es de ir, variables mutables. El segundo (Haskell) es un lenguaje
fun ional puro on ara tersti as propias omo evalua in perezosa (lazy).
3.6.1. ML
ML fue desarrollado por Robin Milner y otros en los omienzos de la d ada de
1970 en la Universidad de Edimburgo. Uno de los prin ipales objetivos fue la implementa in de t ti as de prueba para demostradores de teoremas.
Su nombre proviene de metalenguaje. ML permite introdu ir efe tos olaterales, lo
que lo ha e un lenguaje fun ional impuro, por lo que se onsidera un lenguaje fun ional
on ara tersti as imperativas.
ML utiliza orden de evalua in ansiosa (eager), en parti ular la estrategia denominada all by value y tiene al an e (s ope) estti o. A tualmente existen varios derivados
de ML, omo Standard ML (SML) y O aml.
A ontinua in se muestran algunos ejemplos en O aml.
let average a b = (a +. b) /. 2.0 ;;

En este primer ejemplo se dene una fun in que al ula el valor medio entre dos
valores dados. La senten ia let introdu e un nuevo indenti ador dentro del ambiente
en que se apli a.
Esta fun in tiene tipo
8 La
nota in (a . b) es equivalente a ( ons 'a 'b).

57
val average : float -> float -> float = <fun>

lo que indi a que average es una fun in que toma dos argumentos oat y retorna
un oat. Los operadores (fun iones) +. y /. operan sobre oats.
La siguiente fun in muestra que es posible denir pro edimientos (o fun iones que
retornan void en C, C++ o Java).
let sum a b =
let s = a + b in
Print.printf "Sum=%d\n" s ;;
val sum : int -> int -> unit = <fun>

Cabe notar que no es obligatorio denotar los tipos en las deni iones. ML inere
los tipos de las expresiones desde sus argumentos y operadores. Esto ha e que en ML
los operadores no estn sobre argados, es de ir que ada operador (o fun in) debe
operar sobre tipos on retos.
Es posible denir fun iones re ursivos.
let re fa torial n =
if (n < 0) then (raise Exit) else

mat h n with
0 -> 1
| n -> (n * (fa torial (n-1)));;
La fun in fa torial muestra que es posible disparar ex ep iones (los uales son
valores de un tipo espe o) y re ono imiento de patrones (pattern mat hing).
La deni in de fun iones re ursivas deben denotarse expl itamente por las reglas
de al an e (s ope) del lenguaje. Si se omitiese, la invo a in de fa torial en el uerpo
de su deni in tratara de resolver a un smbolo denido previamente, mas que el
smbolo que se est deniendo. fa torial.
Los tipos bsi os de O aml son: int, bool, har, string, unit.
3.6.1.1. Tipos de datos estru turados

En O aml es posible denir nuevos tipos de datos a partir de otros tipos denidos
previamente. La senten ia
tuplas:
type introdu e
un nuevo nombre de tipo.
un valor de una tupla se dene de la forma
1in
son valores.
Ejemplo de deni in de un tipo basado en tuplas:
type pair = int * int

58
(v1 ,...,vn ),
donde
vi ,
registros (re ords): son omo las tuplas, pero on sus elementos rotulados. Son
equivalentes a las estru turas (stru t) de C o registros de Pas al.
Ejemplo:
type person = {name:string ; id:int};;

...
let p = {name="Haskell Curry", id=1};;
p.name;;
...
Variantes (uniones) y enumera iones: los registros variantes o uniones ( omo

union de C) y las enumera iones (tipos enumerados de Pas al, enum de C, et ),
se denen de manera on isa y elegante omo se muestra el siguiente ejemplo:
type DiaSemana = Dom | Lun | Mar | Mie | Jue | Vie | Sab;;

Los tipos variantes pueden usarse para denir estru turas de datos omo en el
siguiente ejemplo:
type bin_tree = Leaf of int | Tree of bin_tree * bin_tree;;

Ejemplos de expresiones (valores) de tipo bin_tree son:
Leaf 1
Tree (Leaf 3, Leaf 4)
Tree (Tree (Leaf 3, Leaf 4), Leaf 5)
Listas: las listas son las estru turas de
datos mas omunmente utilizadas en la
programa in fun ional. Las listas en ML son homogneas, es de ir que todos

sus elementos deben ser del mismo tipo.
Ejemplos de listas:
[1;2;3
[
(lista va a)
1 :: [2;3
1 :: 2 :: 3 :: [
El operador :: ( ons) onstruye una lista tomando omo su primer argumento la
abeza (head) y su segundo argumento el resto o ola (la ual es una lista).
Las nota iones de listas usando or hetes son un ejemplo de synta ti sugar.
Las listas son un ejemplo de un tipo de datos parametrizado.
Un tipo de datos (o fun in) parametrizado ( on parmetros de tipo) dene una

familia de tipos (o fun iones), llamados omnmente politipos.
El tipo list se puede denir de la siguiente manera:
59
type 'a list = Nil | :: of 'a * 'a list;;

La evalua in de la expresin
1 :: Nil resulta
en
- : int list = :: (1,Nil)

o sea una lista de enteros, en parti ular la lista
Es posible denir la fun in
length (longitud
[1.
de una lista)
let re length a' l =

mat h l with
Nil
-> 0
| _ :: rest -> 1 + length rest;;
3.6.1.2. Referen ias (variables)

El siguiente programa
let my_ref = ref 0;;

ref := 100;;
let value = !my_ref;;
dene una referen ia a una elda en memoria que ini ialmente ontiene el valor 0.
Es posible a eder al valor de una variable v por medio de la expresin
:=
!v. El operador
permite modi ar (asignar) un nuevo valor a una referen ia.

Lo anterior muestra que O aml permite el estilo de programa in imperativa, por
lo que no es un lenguaje fun ional puro.
3.6.1.3. Otras ara tersti as imperativas

La familia de lenguajes derivados de ML generalmente omparten otras ara tersti as imperativas omo arreglos y senten ias de itera in omo while y for.
La denota in de valores de tipo
array
(en realidad dene ve tores o arreglos
unidimensionales) tienen la forma
[|e0 ; . . . ; en |]
El siguiente ejemplo muestra el uso de arreglos on una senten ia de ontrol for.
let a = Array. reate 10 0;; (* reate a array of 10 elements, initialized with 0 *)

for i = 0 to Array.length a - 1 do
a.(i) <- i
done;;
El tipo
array es un
ejemplo de un tipo de dato
Un ampo de un registro puede de lararse omo
mutable.
mutable. Por ejemplo,
est denido omo un registro on un ni o ampo mutable:
type 'a ref = { mutable ontents:'a };;

60
el tipo ref
3.6.2. Haskell
Haskell es un lenguaje fun ional puro, on evalua in lazy, alto orden y pattern
mat hing. Tiene un avanzado sistema de tipos que permite polimorsmo paramtri o
y sobre arga de onstru tores de lases.
De igual forma que ML, Haskell es un lenguaje basado en expresiones, uya evalua in arroja valores, de un determinado tipo, omo resultado. Los tipos de datos bsi os
son
Char, Integer, Float, entre otros. Los tipos

[1,2,3) y las tuplas (ej: ('b',4)).
de datos bsi os estru turados son
las listas (ej:
Los tipos bsi os no dieren de los tipos denibles por el programador, ya que es
posible denirlos en Haskell, pero el lenguaje usa nota iones onvenientes para esos
valores. Por ejemplo, el tipo
Char
puede denir omo una (gran) enumera in om-
puesta de onstru tores onstantes.

Si bien los tipos bsi os no dieren de los dems tipos, Haskell provee algunas
onstru iones sint ti as que favore en la legibilidad de los programas. Por ejemplo
pueden denirse listas por omprensin omo en los siguientes ejemplos:
[ f x | x <- l -- lista de f(x) tal que x re orre

la lista l [ (x,y) | x <- l1, y <- l2 -- produ to artesiano de l1
on l2 [ x | x <- l, x > 0 -- lista de valores positivos de la lista
l
En el ltimo ejemplo se puede ver que en una lista por omprensin pueden in luirse ondi iones, llamadas guardas.
Otra onvenien ia sint ti a son las adenas (strings), las uales se pueden denotar
omo
Hola uando en
['h','o','l','a').
realidad es una lista de ara teres (
Las fun iones se denen en forma similar a ML, es de ir que onsisten en un

onjunto de e ua iones. Por ejemplo la fun in
qui ksort puede
denirse omo
qui ksort [
= [
qui ksort (x:xs)= qui ksort [y | y <- xs, y<x
++ [x ++
qui ksort [y | y <- xs, y<=x
El operador
operador
++
es el onstru tor de listas (similar al operador ons de LISP) y el
es la on atena in de listas.
La nota in
[1..n son abreviaturas sint ti as para denotar se uen ias aritmti-
as. Ejemplos:
[1..5 => [1,2,3,4,5 [5,2..4 => [5,2,3,4 [1,3..

=> [1,3,5,7,9,... (lista infinita)
61
Mas adelante se tratarn en detalle las listas innitas.

Las fun iones son urri adas, es de ir que toman un solo argumento, permitiendo
denir fun iones par iales. A modo de ejemplo, la fun in
add x y = x + y
add :: Integer ->Integer ->Integer.
in = add 1 tiene tipo in :: Integer ->Integer, o sea que su valor
dene una fun in on el tipo

La fun in
de retorno es una fun in. Cuando se apli a a un argumento entero se obtendr un

valor on reto. Por ejemplo,
in 4
retorna
5.
Si se desea des urri ar uan fun in se pueden agrupar los argumentos en una
tupla. Por ejemplo,
add (x,y) = x + y
es una fun in de un ni o argumento.
La apli a in de fun iones es aso iativa a izquierda.

En Haskell tambin es posible denir fun iones lambda, omo por ejemplo
in = \x -> x + 1
Los operadores injos se pueden denir por medio de e ua iones omo ualquier
otra fun in. Por ejemplo, el operador de on atena in de listas est denido omo
[ ++ ys = ys (x:xs) ++ ys = x : (xs ++ ys)

Para ualquier operador injo, es posible denir su pre eden ia (del 0 al 9, donde
9 es la pre eden ia mas alta) y aso iatividad. Por ejemplo, el operador
++
se dene
aso iativo a dere ha on pre eden ia 5.
infixr 5 ++
Los operadores injos aso iativos a izquierda se denen on
iativos on
infix.
infixl
y los no aso-
3.6.2.1. Tipos
En Haskell se dene un nuevo tipo mediante la palabra reservada
data Bool = False | True

data Complex = C Float Float
-- tupla (par) de dos reales
Haskell tambin permite deni iones polimr as.
data Pair a = Pr a a
data BinTree a = Leaf a | Bran h (Tree a) (Tree a)
Es posible denir sinnimos (alias) de tipos, usando
type
type
type
type
data.
String = [Char
Name = String
Address = String
Person = (Name,Address)
62
type.
Tambin es posible denir tuplas on ampos rotulados o registros.
data Point = Pt { oordx, oordy ::Float }

Los nombres de los ampos pueden usarse omo sele tores de omponentes de un
registro:
oordx :: Point -> Float }

oordy :: Point -> Float }
3.6.2.2. Casos y patrones

Como ya se vio anteriormente, en las deni iones de fun iones se usan patrones para
poder ha er deni iones por asos. En los patrones se pueden usar variables mudas
(_) (tambin llamados omodines o wild ards), uando una determinada parte de un
patrn no se ne esita en la parte dere ha de la e ua in.
head (x:_) = x
tail (_:xs)= xs
Existen patrones irrefutables, omo por ejemplo, las variables y otros patrones re-
futables.
El algoritmo utilizado de ompara in de patrones (pattern mat hing) puede tener
xito, puede fallar o puede divergir.
Cuando la ompara in de dos patrones tiene xito (uni an) se produ en ligaduras
(bindings) entre variables y valores. Dos patrones pueden no uni ar, omo por ejemplo
[1,_,[2,x, ya que
dos onstantes diferentes no uni an.
Dos patrones pueden diverger, es de ir, produ ir el valor

plo
[1,2 on [bot,0.9
bot (), omo por ejem-
Los patrones pueden tener una guarda. Por ejemplo
sign x | x > 0 = 1
sign x | x == 0 = 0
sign x | x < 0 = -1
En Haskell los patrones se pro esan de arriba ha ia abajo y de dere ha a izquierda.
Las expresiones
presin
ase tiene
ase permiten
re ono er patrones dentro de expresiones. Una ex-
la forma
ase (x1 ... xk) of

(p11 ... p1k) -> e1
...
(pn1 ... pnk) -> en
9 La
omprara in de bot on 0 diverge.

63
Por ejemplo, las expresiones ondi ionales
if then e1 else e2
es equivalente
ase ( ) of
True -> e1
Else -> e2
3.6.2.3. Evalua in perezosa y sus onse uen ias

Las fun iones en Haskell no son estri tas. Es de ir que la fun in
bot = bot
no termina. Esto quiere de ir que si se dene una fun in onstante de la forma
uno x = 1
la apli a in de
uno bot
retorna 1, ya que la fun in
uno
no usa su argumento y
por lo tanto no es ne esario evaluarlo.

Esto se debe a que Haskell utiliza evalua in peresoza (lazy), la ual es un mtodo
de evalua in all by need.
Una de las ventajas del uso de esta estrategia de evalua in es que, entre otras
osas, permite, por ejemplo, la deni in de estru turas de datos innitas omo en los
siguientes ejemplos.
ones = 1 : ones
from n = n : from (n+1)
squares = map (^2) (from 0)
Como desventaja de la evalua in lazy se puede men ionar el onsumo de memoria adi ional requerido, ya que es ne esario mantener estru turas de datos an no
evaluadas (redu idas) en memoria.
3.6.2.4. Ambientes
A menudo es deseable generar un mbito lo al en una expresin o deni in. Esto
permite ha er deni iones que o ultan detalles de implementa in.
Las expresiones
let
son tiles en asos que se denan mltiples de lara iones.
Por ejemplo:
let y = a * b
f x = (x+y)/y
in f + f d
La lusula
where permite realizar varias deni iones en una e ua in on varias
guardas. Por ejemplo:
64
f x y | y > z = ...
| y <= z = ...
where z = x * x
Expresiones lambda (abstra iones):
\x -> E
donde
es una expresin es equivalente a
x.E
3.6.2.5. Clases y sobre arga de operadores

Las lases permiten denir opera iones omunes a una determinada familia de tipos
de datos.
Por ejemplo, la lase
Eq
10 dene las opera in de
denida en preludio estndar
igualdad y desigaldad para que pueda ser instan iada por un onjunto de tipos on retos.
lass Eq a where
(==), (/=) :: a -> a -> Bool
x == y = not (x /= y)
x /= y = not (x == y)
Las deni iones de las opera iones
== y /= en la lase Eq son opera iones por omi-
sin (default).
En la deni in de tipos de datos on retos, las opera in de igualdad podr ser
una instan ia de la lase
Eq:
instan e Eq Integer where

x == y = integerEq x y
...
instan e Eq Float where
x == y = floatEq x y
donde las fun iones
integerEq
floatEq
son fun iones de igualdad primitivas
para ada tipo de datos, respe tivamente.

La deni in del operador
/=
queda denido (por omisin) en la lase
Eq.
Las deni iones en las instan ias se denominan mtodos.

Las lases pueden derivarse, es de ir que una lase puede heredar de otra, extendindola. Por ejemplo, la lase
Ord
deriva de
Eq.
lase (Eq a) => Ord a where

(<), (<=), (>=), (>) :: a -> a -> Bool
max, min :: a -> a -> a
10 El preludio estndar es omo la bliote a estndar en otros lenguaje de programa in, que ontiene
las deni iones de tipos de datos bsi os y fun iones de uso omn.
65
Cabe a larar que las lases de Haskell no son equivalentes al on epto de lase de
la programa in orientada a objetos. A ontinua in se des riben algunas diferen ias:
Haskell separa la deni in de un tipo de la deni in de los mtodos aso iados
a di ho tipo.
Los mtodos de Haskell se orresponden on las fun iones virtuales de C++.
Las lases de Haskell son similares a las interfa es de Java, es de ir que denen
un proto olo para el uso de objetos en lugar de un objeto en s.
11
Los tipos de Haskell no pueden ser oer ionados.
Haskell no ne esita de virtual tables en tiempo de eje u in.

El sistema de lases de Haskell no ontempla el ontrol de a eso a mtodos. El
sistema de mdulos de Haskell ontempla el ontrol de a eso.
3.6.2.6. Emula in de estado

Mu hos problemas omputa ionales requieren el on epto de estado, omo por
ejemplo, entrada-salida, estru turas de datos omo ontenedores ( ontainers), sistemas de transi in de estados, et .
Un problema pr ti o que requiere la no in de estado es la genera in de nmeros
aleatorios (random). Es posible desarrollar algoritmos que generen una se uen ia de
valores pseudo-randoms. Los algoritmos requieren la no in de estado ya que un valor se
omputa en base a un valor anterior, generalmente llamado semilla (seed). La siguiente
fun in genera un valor pseudo aleatorio a partir de una semilla dada:
type Seed = Int

randomNext :: Seed -> Seed
randomNext seed = if newRandom > 0 then newRandom
else newRandom + 2147483647
where
newRandom = 16807 * lo - 2836 * hi
(hi,lo) = rand `divMod` 127773
Los nmeros aleatorios se utilizan generalmente para simular experimentos que
requieren aleatoriedad. Por ejemplo, se podra denir una fun in que simula la tirada
de un dado:
rollDie :: Seed -> Int

rollDie seed = (seed `mod` 6) + 1
11 Una
oer in es una onversin ( ast) de tipos impl ito.

66
Ahora, si quisiramos simular el lanzado del dado ms ve es, es ne esario que la

prxima semilla sea el valor aleatorio anterior. Esto es posible si el valor generado por
rollDie se representa omo un par: el valor generado y una fun in de genera in del
prximo valor. Habra que redenir la fun in:
rollDie :: Seed -> (Int,Seed)

rollDie seed = ((seed `mod` 6) + 1,randomNext seed)
Esta es la des rip in de un transformador de estados, es de ir un par ompuesto
por un valor y una fun in que representa una transi in al prximo estado en base al
estado a tual. Es posible denir el tipo de un transformador de estados:
donde
s es
s ->(a,s),
un estado y a es el tipo de valores aso iado al estado.
Con esto es posible denir una fun in que, por ejemplo, obtenga un estado on la
suma de los valores de dos lanzamientos del dado:
sumTwoDi e :: Seed -> (Int,Seed)

sumTwodi e seed0 = let (die1,seed1) = rollDie seed0
(die2,seed2) = roolDie seed1
in (die1+die2,seed2)
Sera onveniente tener una fun in que permita en adenar estados de manera ms
general:
type Random a = Seed -> (a,Seed)

(>>) m n :: Seed -> Random a -> Random b -> Random b
(>>) m n = \seed0 -> let (result1,seed1) = m seed0
(result2,seed2) = n seed1
in (result2,seed2)
Con la fun in
>> ( ono ida omo next ) es posible en adenar ( omponer) mltiples
lanzamientos de un dado:
rollDie >> (rollDie >> rollDie)

El problema on el operador
>>
es que retorna el estado nal y no es posible ver
los estados intermedios. Para poder denir algunas fun iones interesantes, omo por
ejemplo, sumar los valores apare idos en ada lanzamiento del dado, es ne esario otra
fun in an ms general:
(>>=) :: Random a -> (a -> Random b) -> Random b

(>>=) f g = \seed0 -> let (result1,seed1) = f seed0
(result2,seed2) = (g result1) seed1
in (result2,seed2)
Ahora, el operador
fun in
>>=
utiliza (o liga) el resultado de la apli a in de
en la
para la obten in del prximo estado. Por esta ligadura, este operador se
ono e generalmente omo bind.

Con el operador
>>=
es posible denir, por ejemplo, una fun in que permita
sumar los valores de una su esin de lanzamientos de dados:
67
addToDie die1 = rollDie >>= (\die2 -> return (die1 + die2))

return :: a -> Random a
return x = \s -> (x,s)
Es posible observar que la fun in return apli ada a un valor dado, retorna una
fun in (transformador de estado) que dado un estado, retorna el valor dado omo
argumento on el mismo estado.
Tambin es posible redenir la fun in
sumTwoDi e utilizando los
operadores bind
y return :
sumTwoDi e :: Random Int

sumTwoDi e = rollDie >> (\d1 -> rollDie >>= (\d2 -> return (d1+d2)))
Lo que se ha denido es una instan ia de una mnada. Una mnada es estru tura
que permite representar diferentes lases de omputa iones. Lo realizado hasta ahora
es un ejemplo de una mnada para representar estado (en realidad transformadores de
estado), ne esario para modelar sistemas on estados, omo por ejemplo genera in de
se uen ias de valores aleatorios o entrada-salida.
Deni in 3.6.1
M
Una
mnada es una tripla (M, return, >>=) donde
es un onstru tor de tipo,
return :: a > M a,
>>=:: M a > (a M b) > M b.

y se umplen las siguientes propiedades:
1.
m >>= return = m
2.
returnx >>= f = f x
3.
(m >>= f ) >>= g = m >>= (x.f x >>= g)
El operador
>>=
(unidad dere ha o right unit).

(unidad izquierda o left unit).
(aso iativa a dere ha).
se denomina omnmente bind y generalmente se le llama a
una mnada.
Las mnadas son un resultado de la teora de ategoras. En 1991, Eugenio Moggi
las utiliz para des ribir la semnti a de diferentes tipos de omputa iones. Dependiendo de la mnada se puede modelar estado, no determinismo (ba ktra king) usando
M a = Either a a).
listas o ex ep iones (
Philip Wadler des ubri que las mnadas
podan implementarse dire tamente en Haskell.

La lase
Monad
en el preludio estndar de Haskell est denida de la siguiente
forma:
68
lass Monad m
(>>=) ::
(>>) ::
return ::
fail ::
where
m a ->
m a ->
m a ->
String
(a -> m b) -> m b
m b -> m b
a
-> m a
m >> k = m >>= \_ -> k

fail s = error s
A ontinua in, se des ribe una mnada espe a para la simula in de estados.
Sea
type StateTrans s a = ST(s ->(s,a)),

a
un tipo que representa un trans-
formador de estados (fun in) para algn tipo ( ) de resultado. Intuitivamente, esta
mnada representa una fun in que dado un estado y un valor, retorna un par ompuesto on otro estado y otro valor.
La idea del transformador de estados es poder arrastrar un estado y una fun in,
la ual permitir obtener el prximo estado a partir del estado a tual.
Haskell introdu e una abstra in lingusti a que es muy onveniente para la laridad de los programas y que evita el uso expl ito del operador
do
>>=:
pat <- expr1 expr2
signi a
expr1 >>= (\pat > do expr2)

y
do
expr signi a expr.
Ahora es posible denir la siguiente instan ia de mnadas:
instan e Monad (StateTrans s)

-- (>>=) :: StateTrans s a -> (a -> StateTrans s b) -> StateTrans s b
(ST p) >>= k = ST (\s0 -> let (s1,a) = p s0
(ST q) = k a
in
q s1
)
-- return :: a -> StateTrans s a
return a = ST(\s -> (s,a))
(notar la similitud on el operador
>>=
denido en el ejemplo de genera in de
nmeros aleatorios).
Intuitivamente, la fun in
ta in (fun in)
>>= toma un transformador de estado p on una ompu-
m b
m b.
la ual produ e otra mnada
produ e un transformador de estados de tipo
69
a partir de valores de tipo
Para poder apli ar elementos f ilmente a esta mnada es onveniente denir la

fun in
applyST :: StateTrans s a -> s -> (s,a)

applyST (ST p) s = p s
Utilizando esta mnada, se implementar, a modo de ejemplo, el algoritmo de
Eu lides para en ontrar el mayor divisor omn de dos enteros positivos.
En un lenguaje imperativo el algoritmo podra denirse omo:
while x != y do
if x < y then
y := y - x;
else
x := x - y;
return x
Para poder es ribir el algoritmo en Haskell simulando estado, es ne esario primero,
denir el tipo que representar el estado y fun iones para a eder y modi ar sus
omponentes.
type State = (Int, Int)

getX, getY :: StateTrans State Int
getX = ST(\(x,y) -> ((x,y),x))
getY = ST(\(x,y) -> ((x,y),y))
setX, setY :: Int -> StateTrans State ()
setX x' = ST(\(x,y) -> ((x',y),()))
setY y' = ST(\(x,y) -> ((x,y'),()))
el estado es simplemente un par, el ual representar las variables
grama imperativo. Las opera iones
getX
getY
del pro-
denen un transformador de estados
(fun in) que dado un estado generan un nuevo estado on los valores de ada omponente requerida. Las opera iones
que retorna el valor
().
setX
setY
denen un transformador de estado
Ahora es posible es ribir el algoritmo de Eu lides.
g d :: StateTrans State Int

g d = do x <- getX
y <- getY
(if x == y then
return x
else if x < y then
do setY (y-x)
g d
else
70
do putX (x-y)
g d
GCDEu lides x y = snd (applyST g d (x,y))

La entrada-salida es modelada en Haskell usando mnadas (IO). En la fun in
getChar :: IO Char
el tipo IO Char indi a que uando getChar sea evaluada, realizar una a in de
tipo IO, el ual es una mnada, on valores de tipo ar ter. Las a iones que no devuelven nada til pueden retornar el tipo () (similar al tipo void del lenguaje C o
C++), omo por ejemplo la fun in putChar :: IO ().
Es pre iso notar que la fun in
getChar no retorna un valor de tipo Char, sino que

IO Char, la ual es
es una fun in de alto orden, ya que retorna una estru tura de tipo
un par (valor,fun in) que ontiene el valor produ ido en ese estado y un transformador
(fun in) de estados. La apli a in de di ho transformador al estado a tual generar
otro par (valor,fun in). De esta forma es posible seguir apli ando otras fun iones de
entrada-salida al estado retornado.
Un programa Haskell en s debe omuni arse on el mundo exterior, as que en
realidad la fun in
main tiene tipo IO ().

IO a se puede interpretar omo:
En general la mnada
type IO a = World -> (a,World)

esto es, que una opera in de entrada-salida ambia el estado del mundo exterior.
El siguiente ejemplo muestra un ejemplo de entrada-salida en Haskell:
e ho = do <- getChar
putChar
La variable
La fun in
getChar
getChar y putChar.
se liga al valor retornado por
uen ialmente las opera iones
return
y el operador
do
ombina se-
es otro operador mondi o, la ual retorna una a in de
entrada-salida aso iada a un argumento.
return :: a ->IO a
return es posible denir
Con el operador
opera iones mas omplejas omo
getLine :: IO String
getLine :: do <- getChar
if == '\n' then return ""
else do l <- getLine
return ( :l)
getLine retorna una a in de entrada-salida (mnada) on valores de
String y simula la siguiente itera in en un lenguaje imperativo omo C:
La fun in
tipo
71
har * getLine()
{
har , *l = mallo (sizeof( har)*MAX_LINE_LENGTH);
int i = 0;
memset(l,MAX_LINE_LENGTH,0);
while (( = get h()) != '\n')
l[i++ = ;
return l;
}
As omo se han des ripto ejemplos de mnadas para manipular o simular estado,
sus apli a iones so mltiples y es posible enumerar:
Estado.
Entrada salida (mnada IO).
Contenedores. Ejemplos: listas, grafos, . . . .
Computa iones que podran fallar: ex ep iones y bsquedas en ontenedores
Maybe).
Parsing (anlisis sint ti o y lexi ogr o).

Las mnadas tienen omo ventaja que fa ilitan la mantenibilidad de los programas, ya que es posible realizar ambios sin modi ar el digo anterior. Por ejemplo,
es muy simple in orporar un nuevo paso en una se uen ia de omputa iones, introdu ir una nueva variable en el estado, manejar ex ep iones, errores y no determinismo.
return x=[x
on at (map f l).
Las listas son un ejemplo de mnadas. La fun in

unitaria y la fun in
En
l >>= f
es equivalente a
retorna la lista
http://www.l .uma.es/ blas/pfHaskell/gentle/fun tions.html
se en-
uentra la versin en astellano del tutorial A Gentle Introdu tion to Haskell el ual
des ribe todos los detalles del lenguaje.
3.7. Ejer i ios

1. Apli ar la fun in
P LU S
a 1 y 2.
2. Denir la fun in IFTHENELSE, la ual tendr la semnti a de una expresin

ondi ional de la forma
if
ondi in
e1 else e2 .
3. Denir la fun in SUB la ual ompute la diferen ia entre dos naturales. Ayuda:
usar PRED.
4. Dada la fun in
N IL x.T RU E
a ) Denir el predi ado
N U LL
que representa la lista va a:
(retorna
72
T RU E
si su argumento es
N IL).
b ) Denir la lista
[1, 2, 3].
5. Apli ar (eje utar) el fa torial de 3.

6. Dada la expresin lambda
(x.x x)((x.x)y):
a ) Redu ir a forma normal usando orden normal.

b ) Redu ir a forma normal usando orden apli ativo.
) Cul estrategia es la mas e iente, en este aso?
7. Denir en LISP la fun in length, que retorna la longitud de una lista.
8. Denir en LISP una fun in que ompute las ra es de una fun in utilizando el
mtodo de bise in (dado un error mximo permitido). Evaluar la longitud del
programa usando length.
9. Implementar en LISP los ombinadores
SKI.
10. Implementar en O aml y Haskell una fun in
reverse que tome un rbol binario
(genri o) y retorne su espejado, es de ir que en ada nodo tiene inter ambiados

sus subrboles izquierdos y dere hos.
11. Implementar en O aml y/o Haskell uns fun in que tome una lista ordenada
de valores de un tipo genri o y retorne un rbol binario balan eado on los
elementos de la lista.
12. Implementar una fun in en O aml y en Haskell que retorne una lista de los
enteros pares positivos. Es ribir un programa que muestre su uso.
13. Implementar en Haskell una fun in
putString:: String IO () que saque por

putChar.
la salida estndar una se uen ia de ara ters dada usando la fun in

14. Implementar en Haskell una fun in
rollNDi e :: Int ->Random [Int.
15. Imprimir pos la salida estndar la lista de valores retornadas por la fun in
anterior.
16. Proponer ambios en la sintaxis y semnti a del lenguaje kernel para onvertirlo
en un lenguaje fun ional puro.
73
Captulo 4
El modelo on estado (statefull)

El modelo o estilo de programa in on estado expl ito permite que un omponente
(un pro edimiento por ejemplo) depende de parmetros internos (su estado) adems
de sus argumentos.
Estos parmetros internos permiten que se memori en valores entre sus a tiva iones.
Esto permite simpli ar algunas tareas que naturalmente requieren la no in de
estado.
El on epto de estado expl ito ha e perder de laratividad en el sentido que las
deni iones ahora se basan en la no in de ambios de estado para llegar a una solu in nal lo ual ha e perder el purismo del modelo apli ativo, entrndose mas en la
utiliza in de omandos de ambios de estado.
Los ambios de estado de las variables se realizan por medio de la opera in de
asigna in, la ual se torna en una opera in fundamental en el modelo imperativo.

Este modelo se ono e omo imperativo ya que se enfo a ms en el mo que en el
qu de un problema. Un programa imperativo des ribe una se uen ia de ambios de
estado para llegar al resultado esperado (estado nal).
En el modelo de larativo, el on epto de estado est impl ito en los valores intermedios utilizados para arribar a la solu in nal.
Los parmetros internos brindan un me anismo de memoria de largo plazo, permitiendo denir programas que evolu ionan, mientras que el estilo de programa in
fun ional brinda un me anismo de memoria de orto plazo, es de ir que los estados
intermedios se des artan (olvidan).
La idea bsi a es que en ste modelo disponemos de eldas, las uales se omportan
omo referen ias a valores.
De manera mas rigurosa, una elda es un par
(nombre) y
ref
(id, ref )
donde
id es
su identi ador
es una referen ia a la memoria de datos.
Es posible modi ar la referen ia de una elda, por eso se di e que las eldas son
74
mutables.
Una elda representa una referen ia o puntero en un lenguaje de programa in
imperativa omo Pas al, C, C++ o Java.
En estos lenguajes una variable es mutable, es de ir puede ser modi ada. Una variable puede ser de un tipo bsi o (entero, ara ter, real, . . . ), estru turados (arreglos,
registros, et ) o una referen ia a un valor.
Las variables de los lenguajes men ionados arriba generalmente son mutables (ex epto las onstantes) y on un al an e y tiempo de vida dependiente del ontexto
(bloque) de su de lara in.
Las referen ias, en estos lenguajes, son variables (tipadas) uyos valores son dire iones de memoria (de la elda que ontiene el valor). En algunos lenguajes ( omo
Java) sus valores referen iados se deben rear dinmi amente mediante operadores espe iales (ej: new ).
Una diferen ia entre las referen ias de C++ y Java es que en C++ son inmutables
y deben estar ini ializadas, es de ir no se pueden ha er apuntar a otra elda (o a null ),
por lo que en C++ son realmente alias de de otras variables.
Generalmente, en los lenguajes on referen ias, el valor referen iado se a ede de

manera impl ita (es de ir que el identi ador de la referen ia denota el valor referen iado). Esto se ono e omo referen ia in impl ita. Ejemplos de estos tipos de
referen ias en ontramos en Pas al, C++ y Java.
Un puntero es similar a una referen ia pero en general pueden asignarse y su ini ializa in es op ional.
Los punteros generalmente tienen aso iados operadores de referen ia in (a eder
al valor del puntero) y eventualmente de desreferen ia in (obtener la dire in de
memoria de una variable).
El lenguaje C tiene ambos operadores (* y & ), respe tivamente.
Los punteros no son alias de la variable (ya que pueden ambiar de variable apuntada), aunque s es posible onstruir distintas expresiones que pueden denotar una
misma entidad (valor) en un momento dado.
De esta manera es posible denir una referen ia omo una abstra in de un puntero, en el sentido que un puntero puede verse omo un valor uando una referen ia
es un tipo abstra to de datos (TAD) que en apsula y o ulta un puntero, el ual slo
puede manipulado por sus opera iones (asigna in, referen ia in y desreferen ia in).
En general ambos tipos de datos son tipos de datos parametrizados sobre el tipo
de valores al que ha en referen ia.
Existen lenguajes, omo Pas al y C++ que ontiene ambos tipos de datos: referen ias y punteros. Otros, omo Java slo tienen referen ias.
75
4.1. Semnti a de eldas

Existen opera iones bsi as sobre eldas:
{NewCell X C}:
rea una nueva elda
C on valor ini ial X.
{Ex hange C X Y}: liga (atmi amente) el ontenido de X on el ontenido de C

y C toma el nuevo valor Y.
C := X
C:
(asigna in): el nuevo ontenido de
retorna el valor referen iado por
Se permitir usar la asigna in
es
X.
C.
C := X omo una expresin la ual arroja el valor

X = C := Y es equivalente a {Ex hange C X Y}.
anterior de C. O sea que la senten ia
Antes de poder denir la semnti a de las nuevas opera iones es ne esario ampliar
el modelo de la mquina abstra ta. Es ne esario una nueva memoria, denominada
memoria mutable (mutable store)
la ual ontendr las eldas (ini ialmente va a).
Esta memoria ontiene un onjunto de pares, denotados omo

identi ador
x : y , donde el
y puede ser
est ligado al nombre de la elda (identi ador interno) e
ualquier valor par ial. El identi ador interno juega el rol de dire in de memoria
del valor refere iado.

Un estado de eje u in de la mquina abstra ta ahora se onvierte en una tripla
(ST, , ).
A ontinua in se des ribe la semnti a de las opera iones sobre eldas, des ribiendo el omportamiento de la mquina on ada estado de eje u in involu rando
las opera iones bsi as sobre eldas.
({N ewcell < x >< y >}, E)

1. Crear un nombre (valor) ni o (n) en
2.
bind(E(< y >), n)
en
para la elda.
3. Si la ligadura tuvo xito, agregar el par
(E(< y >) : E(< x >)) a la memoria
.
4. Si la ligadura fall, generar un error.
({Exchange < x >< y >< z >}, E)

1. Si
E(< x >)
es determinado, ha er:
E(< x >) no est ligado a un nombre de una elda, error.

Sea (E(< x >) : w) :
1) A tualizar tal que ontenga el par (E(< x >) : E(< z >)).
2) bind(E(< y >), w) en .
a ) Si
b)
2. Sino, la mquina pasa al estado
76
Suspended.
Se debe notar que las dems opera iones sobre eldas

en trminos de
Ex hange y
C
C:=X
se pueden denir
se dejan omo ejer i io.
La semnti a dada, simula el ambio de valores de las eldas por medio de la

memoria
aunque es importante notar que no se realizan ambios en los valores
bsi os del programa, ya que siempre se en uentran en la memoria inmutable
Las implementa iones ara tersti as de los lenguajes imperativos slo mantienen
la representa in de la memoria
(id, ref )
donde ada elda se puede representar on un par
si el lenguaje es interpretado.
En el aso de un lenguaje ompilado, los identi adores se reemplazan on la dire in de memoria del valor referen iado y un puntero o referen ia es un valor que
ontiene una dire in de memoria (la del valor referen iado o una dire in espe ial
usada para denotar que no se ha e referen ia a algn valor en parti ular, omo el valor
null de Java).
En un programa ompilado generalmente la memoria
ontiene dire tamente los
valores de los tipos de datos denidos en el programa, es de ir que los identi adores
estn impl itamente aso iados a las dire iones de memoria en que se alma enarn
sus valores.
La in lusin en la mquina abstra ta de la memoria mutable
requiere que se
redenan los on eptos de al anzabilidad y del re lamo de eldas para el re ole tor de
basura.
Deni in 4.1.1
Una variable
y es al anzable si ontiene x:y y x es al anzable.
Si la variable x no es al anzable
y) es posible eliminarlo on seguridad.
Deni in 4.1.2
ualquier
ontiene el par
x:y
(para
4.2. Aliasing
Dos variables son alias (sinnimos) si se reeren a la misma entidad ( elda).
Es obvio que en el modelo on estado expl ito es muy omn que se produz a
aliasing. El problema del aliasing es que ompli a el razonamiento sobre los programas,
ya que el ambio a una variable puede afe tar a la otra (alias) ya que denotan la misma
entidad.
En programas grandes es dif il para el programador llevar la pista de las variables
que pueden ser alias en alguna instan ia de eje u in.
Este es el prin ipal motivo del porqu la abstra iones de datos son ade uadas en
el modelo on estado expl ito.
La idea bsi a de la abstra in de datos es el en apsulamiento del estado, esto es,
el o ultamiento del estado dentro de omponentes. El estado slo puede ser modi ado
a travs de sus opera iones. Estas son las ideas bsi as de los tipos abstra tos de datos
(ADTs) y su objetivo es minimizar los efe tos olaterales de las opera iones, ya que
ada valor slo se puede manipular por medio de sus opera iones orrespondientes.
77
4.3. Igualdad
En el modelo de larativo se vio que la la igualdad requerida es la estru tural ya
que tiene sentido que dos valores son iguales si poseen la misma representa in.
En el modelo imperativo podemos tener el siguiente aso:
X=\{NewCell 10}
Y=\{NewCell 10}
La ompara in
X==Y debera arrojar true?
La respuesta es laramente no, porque estamos omparando eldas, ada una de

las uales tiene identidad propia. Si se modi a el ontenido de una elda, no se afe ta
a la otra.
Este tipo de igualdad se ono e omo igualdad de tokens en ontraposi in de la
igualdad estru tural. Se puede notar que se orresponde a la ompara in de punteros
o referen ias en lenguajes omo Pas al, C y C++, lo que signi a ompara in de
valores que representan dire iones de memoria.
El modelo presentado aqu es muy similar a las referen ias de la familia de lenguajes fun ionales ML.
Obviamente en una expresin
X==Y se realiza la ompara in habitual de valores
(entailment he k).
4.4. Constru in de sistemas on estado

En la onstru in de grandes programas (sistemas) es fundamental tener el ontrol sobre su omplejidad para permitir su anlisis y su mantenibilidad ( orre in,
adapta in y extensin).
Los grandes sistemas requieren que puedan verse omo varias partes o subprogramas ombinados entre s.
Los sistemas deben tener las siguientes propiedades, las uales son diferentes lases
de un prin ipio mas general: abstra in.
En apsulamiento: debera ser posible o ultar los detalles internos de ada parte
(information hidding).
Composi ionalidad: se deberan poder ombinar las partes para formar otras.
Instan ia in/invo a in: debera ser posible rear varias instan ias a partir
de una misma deni in. Este me anismo permite la reutiliza in de partes.
78
4.4.1. Razonando on estado

Partes de un programa imperativo puede tener efe tos olaterales : modi a in de
variables que pueden ser usados en otras partes del programa. Esto, junto al problema
de aliasing, ha e extremadamente dif il el razonamiento de los programas imperativos.
El en apsulamiento permite redu ir la omplejidad de los estados.
El razonamiento sobre estados requiere que ada onstru in o senten ia del lenguaje tenga denida su semnti a en base a mo transforma el estado previo a su
eje u in. Esta semnti a se ono e omo semnti a axiomti a, ya que ada regla de
transforma in de estado se dene omo un axioma de una lgi a.
Los mtodos de razonamiento se basan en que es posible denir invariantes de

omponentes (prin ipalmente en itera iones).
Un invariante es un predi ado (fun in booleana) que estable e que en ese punto
del programa ese estado debera valer (ser verdadero).
Es posible expresar o espe i ar el omportamiento de una parte de un programa
en base a su estado de entrada o pre ondi in, su estado de salida o post ondi in
y su invariante, el ual espe i a una ondi in de su evolu in o rela in entre sus
(prin ipales) variables.
El invariante da una idea de la evolu in de una parte de un programa pero no de
su omportamiento o naliza in. Para esto es pre iso dar una idea de progreso.
Lo anterior muestra que la onstru in de programas imperativos no es tan simple
omo en la programa in de larativa, por lo que es onveniente mantener los omponentes de un programa tan de larativos omo se pueda, ya que el razonamiento
e ua ional es mas f il y omposi ional.
4.4.2. Programa in basada en omponentes

Las tres propiedades, en apsulamiento, omposi ionalidad e instan ia in, denen
la programa in basada en omponentes.
Un omponente es una parte de un programa que dene dos osas: una ha ia el
exterior, su interfa e y otra ha ia adentro, su implementa in.
Los omponentes de pueden denir a diferentes niveles.
Abstra in pro edural:
el omponente se denomina la deni in de pro e-
dimientos y sus instan ias son las invo a iones o llamados a pro edimientos.
Fun tores (unidades de ompila in): pueden
ser ompilados en forma se-
parada. Sus deni iones son fun tores y sus instan ias mdulos.
Componentes on urrentes: un sistema on entidades independientes, intera tuando entre s por medio de mensajes.
1 Es bien ono ido la apli a in de la lgi a de Hoare para razonar sobre programas on estado
expl ito.
79
Los sistemas basados en omponentes se onstruyen prin ipalmente en base a omposi in: un nuevo omponente ombina instan ias de otros.
La programa in orientada a objetos provee me anismos para la deni in y uso de
omponentes, on un me anismo adi ional para la deni in de nuevos omponentes:
la heren ia.
La heren ia permite denir un nuevo omponente mediante la extensin de otros.
Estas extensiones pueden ser espe ializa iones, alternativas de implementa in, entre
otras. Este me anismo permite otra dimensin adi ional para la deni in in remental
y jerrqui a de omponentes.
Se analizarn los detalles de la programa in orientada a objetos en el aptulo 7.
4.5. Abstra in pro edural

Un pro edimiento es una abstra in de un omando, es de ir una a in parametrizada. Una fun in es una abstra in de una expresin (denota un valor).
Para que una abstra in pueda reutilizarse deben poder parametrizarse, es de ir
que se pueda denir en trminos de datos de entrada los uales sern instan iados en
ada invo a in.
Los parmetros usados en la deni in de una abstra in pro edural (pro edimiento o fun in) se denominan parmetros formales.
Los valores apli ados en una invo a in a un pro edimiento o fun in se denominan
parmetros a tuales o reales.

La mayora de los lenguajes de programa in permiten uno o varios me anismos de
pasajes de parmetros. Estos me anismos de pasajes de parmetros denen diferentes
tipos de ligaduras entre los parmetros a tuales y formales.
A ontinua in se da una lasi a in de los diferentes me anismos de pasajes de
parmetros.
Por opia
por valor
(o de entrada): el parmetro formal se liga a una opia del
parmetro a tual. Cualquier modi a in al parmetro formal no afe ta al

parmetro a tual.
por resultado (o salida): el parmetro formal se opia al parmetro a tual

durante el retorno. En la entrada al pro edimiento el parmetro formal no
est ligado a ningn valor on reto.
por valor-resultado
(o entrada-salida): ombina in de los dos me anis-
mos anteriores.
Denota ionales
80
por referen ia:
el parmetro formal se onvierte en una nueva identidad
del parmetro a tual. El parmetro puede usarse libremente. Este es el me anismo usado por el lenguaje kernel utilizado.
Algunos lenguajes imperativos usan una pequea variante de este mtodo,
pasando la identidad (ej: dire in de memoria) del parmetro a tual. El
parmetro formal se a ede (indire tamente) usando esa identidad. En la
pr ti a, se a ede al valor del parmetro usando dire ionamiento indire to.
Este me anismo se ono e omo pasaje variable o por dire in.
por nombre:
la expresin (sin evaluar) que denota el parmetro a tual se
liga al parmetro formal. Cada referen ia al parmetro formal, dentro de

la subrutina, lanza la evalua in de la expresin aso iada. En general se
implementa aso iando al parmetro formal una fun in, la ual es evaluada
en ada referen ia al parmetro formal.
El me anismo ono ido omo
por ne esidad (by need) es una modi a in
del me anismo anterior, donde la expresin (o fun in) se evala una sola
vez. Las prximas referen ias al parmetro formal retornarn el resultado
que se re uerda.
4.6. Ejer i ios

1. Denir las siguientes expresiones en base a la opera in primitiva Ex hange.
a ) X = C := Y
b ) C := X
) X = C
2. Implementar la fun in
Reverse L,
la ual retorna la reversa de una lista utili-
zando estado.
3. Implementar en el lenguaje kernel on estado el tipo de datos Sta k. Es ribir un
ejemplo de su uso.
4. Determinar el tipo de pasaje de parmetros que usan los siguientes lenguajes:
a ) Pas al
b) C
) C++
d ) Java
e ) Haskell
5. Dar esquemas en el lenguaje kernel on estado para simular ada uno de los
me anismos de pasajes de parmetros des riptos.
81
Captulo 5
Lenguajes de programa in
imperativos
En este aptulo se analizan algunos on eptos omunes a varios lenguajes imperativos, en parti ular senten ias omunes de ontrol y tipos de datos generalmente
utilizados.
En la se in 5.4 se ha e una des rip in general del lenguaje C, el ual es un punto
de partida para el estudio de varios lenguajes derivados omo C++, Obje tive C, Java
y C#.
Los lenguajes de programa in imperativos generalmente tienen onstru iones sint ti as para realizar de lara iones (y parti ularmente deni iones) de entidades, omo
variables, onstantes, tipos de datos y pro edimientos y fun iones. Los lenguajes mo-
1 , on-
dernos, los uales se basan en los on eptos de la programa in estru turada
tienen senten ias de ontrol y omputa iones (asigna in) y generalmente proveen
operadores bsi os y me anismos para onstruir expresiones.
Generalmente los me anismos de abstra in que proveen son la abstra in pro edural y fun ional y las deni iones de nuevos tipos de datos.
5.1. De lara iones

Generalmente un programa es un onjunto de de lara iones. Algunas de lara iones
introdu en nuevas entidades, por lo que se denominan deni iones, omo lo son las
deni iones de variables, de nuevos tipos de datos y de pro edimientos y fun iones.
Algunas de lara iones simplemente ha en referen ia a entidades existentes, omo
por ejemplo una de lara in de una referen ia externa, tpi a de lara in de las entida-
1 La programa in estru turada se basa en el uso de senten ias de ontrol de ujo on una semnti a
bien denida y la prohibi in del uso de ontrol de ujo basado en instru iones de saltos (goto).
82
Lenguajes de programa in imperativos
des en la interfa e de un mdulo o una de lara in por adelantado (forward), es de ir

la de lara in de una entidad que se en uentra denida ms adelante en el programa.
5.2. Expresiones y omandos

Algunas senten ias en un lenguaje imperativo toman la forma de expresiones o
omandos de ontrol de ujo de eje u in.
Una expresin representa un valor (de algn tipo de datos). Los omandos no denotan valores, sino que representan onstru iones sint ti as de ontrol estru turado
del ujo de eje u in de las senten ias que ontienen.
La opera in fundamental de mputo es la asigna in y la evalua in de expresiones.
En algunos lenguajes la senten ia de asigna in es un omando (ej: Pas al, Eiel),
mientras que en otros es una expresin.
Cuando la asigna in toma la forma de una expresin permite realizar asigna iones
mltiples en se uen ia, omo su ede, por ejemplo, en C.
Las expresiones se forman a partir de valores onstantes (literales o agregados,
dependiendo su se orresponden on valores de tipos bsi os o estru turados, respe tivamente) y operadores. Los operadores son abstra iones lingusti as ade uadas las
uales se tradu en o implementan on opera iones de mquina ( omo suma, multipli a in, et ) sobre algunos tipos de datos bsi os (ej: enteros y reales en punto otante)
o bien omo invo a iones a fun iones de bibliote a, en el aso que no sean soportadas
dire tamente por el hardware (ej: fun iones trigonomtri as, genera in de nmeros
aleatorios, et ).
Los operadores predenidos en el lenguaje generalmente respetan algn orden de
pre eden ia y tienen alguna regla de aso iatividad (a izquierda, dere ha o no son
aso iativos).
Los lenguajes imperativos omo Pas al o C, son lenguajes monomr os, es de ir
que no soportan polimorsmo. Algunos operadores son polimr os (ej: operador +
de Pas al, el ual suma enteros, reales, on atena strings y adems ha e unin de
onjuntos) pero generalmente se implementan por sobre arga, es de ir mediante la
implementa in de varias fun iones diferenetes on argumentos de diferentes tipos. El
ompilador o intrprete invo a a la fun in orrespondiente en base a los tipos de sus
operandos.
Algunos lenguajes de programa in modernos, omo por ejemplo C++, permite
que el programador sobre argue los operadores del lenguaje ( on algunas po as ex ep iones).
Los omandos o senten ias de ontrol se pueden lasi ar en las siguientes ategoras:
Bloque o se uen ia:
grupos de senten ias
begin s0 ; s1 ; . . . sn end
las uales
se eje utar en se uen ia. Los delimitadores de bloque mas usados son los pares
83
begin,end, { , }, et . En algunos lenguajes los bloques no estn delimitados por

palabras laves (keywords), sino por reglas de indenta in, omo por ejemplo en
Python y Haskell.
Sele in: senten ias de la forma if < ond>then <s1>else <s2>end y sus variantes ( lusulas
elseif < ond2 ...). Estas ltimas lusulas son usualmente
abrevia iones sint ti as de varias senten ias de sele in
if
anidadas.
Otra senten ia de sele in omn es la de sele in por asos, omo la senten ia
ase de Pas al o la senten ia swit h de C, C++ o Java.
Estas senten ias permiten implementar una espe ie de tablas de despa ho para diferentes grupos (bloques) de senten ias. Mu hos lenguajes requieren que
los valores de ada aso sea una onstante, aunque algunos permiten que sean
expresiones evaluables en tiempo de eje u in.
Itera in: permiten repetir la eje u in de un bloque un ierto nmero de ve es.

Existen diferentes tipos de senten ias de itera in:
Indenida : omo los lsi os omandos
while, o repeat-until. Estas sentenwhile),
ias pueden repetir la eje u in de su uerpo ero ( omo en aso del
una o un nmero indenido de ve es, es de ir que pueden no terminar.
Denida : omo el lsi o omando
for, uya variable de ontrol permite que

2
el uerpo se eje ute un ierto nmero de ve es .
Se uen iadores:
saltos (ej:
goto label)
y saltos omputados (donde
label
puede ser una expresin la ual deber ser evaluada dinmi amente. Estos ltimos tipos de saltos se en uentran en Fortran, algunas versiones de BASIC y
omo extensin al lenguaje C en el ompilador C de GNU (g ).
Las senten ias de salto generalmente restringen el destino a la abstra in pro edural que las ontienen, lo ual prohibe que se generen saltos intrapro edurales.
Los saltos, aunque generalmente son senten ias prohibidas en la programa in
estru turada, son tiles en iertos asos uando se apli a programa in defensiva ( hequeos de argumentos y veri a iones de ondi iones esperables) lo ual
produ ira digo dif il de leer (por los mltiples anidamientos de hequeos y
posiblemente repeti in de digo) y po o e iente.
Es omn en ontrar el uso del
goto en digo de sistemas operativos u otro sof-
tware de base.
El uso ms apropiado de senten ias tipo
goto es omo va de es ape a digo de
re upera in de errores.
Estas t ni as aen en desuso si el lenguaje provee ex ep iones.
2 En
el lenguaje C (y mu hos de sus derivados), el omando for puede tomar la forma de un while.
84
Algunos lenguajes, omo por ejemplo C y sus derivados, proveen senten ias de
saltos estru turados, generalmente ono idos omo es apes. Ejemplos de este tipo
ontinue, los uales slo pueden apare er dentro de

swit h (para salir de un aso) y en las itera iones
while, do-while, for. El omando break salta al nal de la senten ia y el
omando ontinue salta al omienzo (slo en itera iones).
se senten ias son
break
determinados omandos, omo
Otra senten ia que puede onsiderarse un es ape es
return en
varios lenguajes
omo C, Fortran, et .
5.3. Ex ep iones
Las ex ep iones son senten ias estru turadas para atrapar ( ontrolar el ujo de
eje u in) en la o urren ia de situa iones ex ep ionales, omo ex ep iones generadas
por el hardware (ej: divisin por ero, o error de es ritura en un ar hivo) o por software
(ej: por in umplimiento de una ondi in esperada o por el ven imiento de una alarma
o timer).
Una forma muy omn de las ex ep iones en mu hos lenguajes de programa in
modernos es la siguiente:
try
<bloque>
at h(e1:T1) < h1>. . . at h(en:Tn) < hn>
on el signi ado informal de que si o urre una ex ep in en <bloque> de tipo

se eje uta el bloque (ex eption handler)
hi,
on
Ti,
1 i n.
Es posible que la senten ia soporte la deni in de un manejador de ex ep iones

por omisin (default), el ual generalmente toma la forma
nally <hd>.
Las ex ep iones permiten una mejor estru tura in del digo en la programa in
defensiva, lo ual permite que el digo sea mas legible sin perder e ien ia en la eje u in.
Si se produ e una ex ep in durante la eje u in de un bloque que no atrapa la
ex ep in, su eje u in se interrumpe y se retorna a su invo ante, para luego repetirse
el pro eso. Esto se ono e omo propaga in de la ex ep in.
Como se puede apre iar, la propaga in de una ex ep in sigue la adena dinmi a
de invo a iones.
Si la propaga in de una ex ep in al anza al bloque ini ial del programa, la ex ep in es atrapada por el manejador por omisin generado automti amente por el
intrprete o ompilador, el ual generalmente, imprime un mensaje orrespondiente a
la ex ep in o urrida y luego naliza el pro eso.
5.4. Introdu in al lenguaje C

El lenguaje C fue muy popular desde su apari in en 1970, desarrollado por Dennis
Rit hie en los laboratorios de AT&T.
85
Es un lenguaje que tiene ara tersti as de bajo y alto nivel, por lo que se onsidera
un lenguaje de nivel intermedio. El lenguaje C ha sido ampliamente utilizado para el
desarrollo de software de base omo sistemas operativos, ompiladores e intrpretes de
lenguajes de programa in, y mu hsimos utilitarios.
Generalmente es la base de mu hos sistemas de omputa in, omo por ejemplo en
los sistemas tipo UNIX.
El nombre del lenguaje viene del he ho que Rit hie lo desarroll omo una extensin
al lenguaje B.
AT&T desarroll UNIX es rito asi ompletamente en C. Era la primera vez que se
un sistema operativo se es riba en un lenguaje de programa in de alto nivel. Hasta
enton es, los sistemas operativos se es riban en assembly. La posibilidad de ontar on
un sistema operativo es rito en un lenguaje de alto nivel, tena grandes ventajas ya que
fa ilitaba su omprensin, mantenibilidad y portabilidad a diferentes arquite turas.
En los omienzos de los 80 se form el omit para la estandariza in del lenguaje C,
el ual se publi el Standard ANSI C en 1989, el ual in luye los ontenidos mnimos
de su bibliote a estndar.
En 1990 la International Organization for Standarization, publi el estndar ISO
9899-1990, el ual es pr ti amente un dupli ado del ANSI 89.
C ha inuen iado a mu hos lenguajes de programa in desarrollados posteriormente, los uales lo extienden in luyendo on eptos de programa in orientada a objetos
(POO) y en algunos asos eliminando algunas ara tersti as no deseadas. Estos lenguajes se ono en omo derivados de C y podemos men ionar Obje tive C, C++, Java,
C# y otros.
5.5. Estru tura de un programa C

Un programa C es una se uen ia de de lara iones, deni iones y dire tivas del
prepro esador.
Las de lara iones y deni iones pueden ser de variables, onstantes, tipos o fun iones.
Las dire tivas del pro esador pueden ser utilizados para in luir otros ar hivos fuente, denir onstantes simbli as y ma ros. Mas adelante se profundizar en el uso de
las dire tivas del prepro esador.
En la gura 5.1 se puede ver la estru tura de un programa C.
Este ontiene la deni in de una onstante simbli a por medio de la dire tiva
dene del prepro esador y la deni in de dos fun iones: la fun in

ir le_area
: f loat f loat
la ual omputa la super ie de un r ulo, tomando su radio omo argumento, y

la fun in main (prin ipal), que invo a (llama) a la fun in ir le_area y muestra su
valor retornado por la salida estndar
3 La
salida estndar se orresponde omnmente a la onsola, aunque se puede redirigir.

86
#in lude <stdio.h>

#define PI 3.141516
float ir le_area(float radius)
{
return PI * (radius * radius);
}
int main(void)
{
float result;
result = ir le_area(10.0);
printf("Area:%f\n",result);
return 0;
/* return pro ess exit ode */
Figura 5.1: Ejemplo de un programa C
main), por donde
La fun in prin ipal (
el programa ini ia, est denida omo que
retorna un integer, tal omo se sugiere en los sistemas POSIX
4 ompatibles. El valor
retornado por main es tomado por el sistema omo el digo de naliza in del pro eso
(el ual puede ser onsultado por el pro eso que lo re).
La palabra void en el argumento de la fun in main indi a que la fun in no tiene
argumentos. La palabra void usada omo tipo de retorno en una fun in signi a que
no retorna valor alguno (es un pro edimiento ).
Como se puede apre iar en la gura 5.1, una fun in tiene aso iada una senten ia
de bloque delimitada por llaves ({,} ).
Dentro de un bloque es posible realizar de lara iones (de variables, onstantes, et )
y a ontinua in se denen las a iones (senten ias) a eje utar en el bloque.
Cada senten ia debe nalizar on un punto y oma (;).
La dire tiva del prepro esador in lude utilizada in luye el ar hivo de abe era
stdio.h, el ual es provista por ualquier ompilador ANSI C, ontiene las de lara iones
ne esarias para realizar entrada-salida.
La fun in printf permite imprimir ( on formato) valores por la salida estndar.
Mas adelante se entrar en mayor detalles on respe to a la entrada-salida en C.
El lenguaje C no ontiene primitivas de entrada-salida. Todas las opera iones de
entrada-salida se realizan por medio de fun iones de bibliote a.
4 Estndar que dene una interfa e (system alls) de un sistema operativo. Esta interfa e est
denida en C
87
5.6. El ompilador C
El onjunto de herramientas en un entorno de desarrollo C bsi amente ontiene:
1. el pre-pro esador: toma las dire tivas en el ar hivo fuente y las reemplaza por
su evalua in (o expansin). Por ejemplo, en el programa de la gura 5.1 ada
referen ia a PI es reemplazada (expandida) a 3.141516.
2. el ompilador C: genera un ar hivo on digo assembly a partir de un ar hivo
fuente C.
3. el assembler : genera un ar hivo objeto a partir de un ar hivo fuente en lenguaje
assembly. Un ar hivo objeto es un ar hivo binario no dire tamente eje utable.

Puede ser utilizado por el linker para generar un programa (ar hivo eje utable).
Mas adelante se entrarn en mayores detalles sobre estos on eptos.
4. el linker : ombina ar hivos objetos y bibliote as para generar un ar hivo eje utable (programa).
5. el debugger : permite eje utar un programa para depura in, esto es, permite denir puntos de parada (breakpoints), ver valores de variables durante la eje u in,
modi arlos, et .
6. otras (make, libtool, . . . ): son herramientas para el ontrol de la ompila in
(ej:make) y genera in de bibliote as (ej:libtool). La herramienta
make
dirige el
pro eso de ompila in en base a una espe i a in (Makele), en la ual se

des riben las dependen ias entre los diferentes mdulos de un programa y las
a iones a tomar uando algunas de esas dependen ias requiera a tualizarse (ej:
un ar hivo obje to on respe to a su ar hivo fuente).
5.7. Compila in de un programa

Si bien esto depende del ompilador y del entorno de desarrollo utilizado, aqu se
asumir que se ompilar desde una onsola o terminal orriendo un intrprete de
omandos (shell) del sistema operativo.
Todos los ejemplos de ompila in asumirn que se dispone del ompilador C libre
de la ole in de ompiladores de GNU
5 el ual in luye un ompilador C.
El programa de la gura 5.1, asumiendo que se en uentra en el ar hivo fuente
example1. , se puede ompilar mediante el omando
g example1.
Esto generar (en aso que no existan errores en el programa) un programa (ar hivo
eje utable) a.out, el ual se podr eje utar introdu iendo el omando
5 La funda in GNU tiene omo objetivo el desarrollo de un sistema operativo y apli a iones libres,
es de ir sin restri iones en las li en ias sobre su uso (http://www.gnu.org/).
88
./a.out
lo que indi ar al shell que eje ute el programa a.out que se en uentra en el dire torio orriente (./).
La op in del ompilador (ag) -o <lename> permite que el programa de salida
tome otro nombre que a.out. El siguiente ejemplo muestra la ompila in del programa
anterior que genere el eje utable on el nombre de programa example1
g example1. -o example1
Si se en uentra en la plataforma MS-WINDOWS el programa de salida deber tener
extensin .exe.
En los sistemas tipo UNIX (ej: GNU/Linux) se puede obtener mas informa in
sobre las op iones del ompilador mediante el omando
man g
(man es la abreviatura de manual ).
5.8. El pre-pro esador

El pre-pro esador pro esa (expande o evala) dire tivas que se distinguen de otras
senten ias del lenguaje C porque estn pre edidas por el smbolo # (numeral).
En la tabla 5.2 des riben algunas dire tivas del pre-pro esador.
Dire tiva
Des rip in
#in lude le
Inserta el ontenido de le.
#dene def
#ifdef symbol
Dene un smbolo o una ma ro.
b1
#else
b2
#endif
Expande
b1
si symbol est denido,
b2
en otro aso.
Figura 5.2: Algunas dire tivas del pre-pro esador.
En la dire tiva
#in lude, le
puede en errarse entre ngulos (<y >), lo ual ha e
que el ar hivo se busque en los aminos (paths) pre-denidos o dados en el omando de

ompila in (op in -I en el ompilador g ). Si le se en ierra entre omillas dobles
("), se bus a en el dire torio orriente.
La dire tiva
#define
permite denir smbolos o ma ros. Una ma ro es una ex-
presin parametrizada a ual ser expandida en ada o urren ia en el programa por

su deni in, realizando una sustitu in textual de los parmetros formales por los
a tuales.
A modo de ejemplo, el siguiente fragmento de programa, muestra su utiliza in.
...
#define MAX_SIZE 1024
89
...
#define max(A,B) ((A>B)?A:B)
...
int x,y,z;
float delta,f,g;
...
x = max(y,z);
/* x = ((y>z)?y:z) */
delta = max(f,g) /* delta = ((f>g)?f:g) */
...
Cabe ha er notar que una ma ro no es equivalente a una fun in. Una fun in
es tipada (tipo de su resultado y sus argumentos), mientras que una ma ro no. A
menudo los programadores C utilizan ma ros para denir expresiones las uales sern
utilizadas sobre diferentes tipos de datos, lo ual permite implementar una forma de
polimorsmo paramtri o ad-ho (basado en sustitu in textual).
5.9. Tipos de datos bsi os

Tipo
Des rip in
har
ara teres (generalmente representados en un byte)
int
enteros (16, 32 o 64 bits, depende de la plataforma)
short int
entero orto
long int
entero largo
oat
real (representa in en punto otante)
double
real de doble pre isin

Figura 5.3: Tipos de datos bsi os
El lenguaje C es un lenguaje estti amente tipado, es de ir que se realiza el hequeo de los tipos de los valores involu rados en ualquier opera in en tiempo de
ompila in.
C ofre e un onjunto de tipos de datos bsi os que se muestran en la tabla 5.3. Mas
adelante ver el tipo de datos puntero, el ual tambin es un tipo bsi o, pero al que
se dedi ar una se in espe a.
Adems de los nombres de los tipos bsi os men ionados, stos pueden ser pre edidos por la palabra reservada
unsigned, lo ual signi a que no pueden tener valores
negativos.
Cabe ha er notar que el tipo har en C es onsiderado un tipo numri o (generalmente se representa en un byte) y sus valores generalmente se orresponden a algn
digo de ara teres estndar (ej: ASCII).
90
5.10. De lara iones y deni iones

En el lenguaje C pueden existir diferentes tipos de de lara iones y deni iones.
Una deni in introdu e una nueva entidad, mientras que una de lara in es un
on epto ms general que puede involu rar una deni in.
5.11. Deni iones de variables

Una de lara in puede introdu ir (denir) variables de un determinado tipo. Una
de lara in de variables tiene la forma:
<type> id1 [=value, id2 [=value, ... ;

donde id1, id2, . . . , son los identi adores (nombres) de las variables, <type>es su
tipo (ej: int, har, . . . ) . Se puede dar un valor ini ial a una variable.
A modo de ejemplo, las siguientes de lara iones denen dos variables de tipo entero,
una de tipo har y otra de tipo oat.
int x,y;
har ;
float f = 3.14;
Se debe notar que slo la variable f est ini ializada.
5.12. Deni iones de onstantes

Se introdu e una onstante ante ediendo a una de lara in omo la de la se in
anterior la palabra reservada
onst.
Ejemplo:
onst float Pi = 3.14;

Algunos programadores preeren de larar valores onstantes por medio de la dire tiva del prepro esador #dene. La diferen ia fundamental es que una onstante
denida omo una variable
onst o upa memoria mientras que una dire tiva no.
El modi ador onst es mas utilizado en la de lara in de parmetros formales

para indi ar que el uerpo de la fun in no debe modi ar el argumento. El ompilador
puede dete tar un intento de modi a in del argumento y en ese aso arrojar un
error de ompila in.
5.13. Deni iones de tipos

C permite denir nuevos tipos a partir de los tipos bsi os. Es posible denir
enumera iones las uales son onstantes simbli as (de tipo entero).
6 La nota in <x>denota que x es una ategora sint ti a (los smbolos menor y mayor no deben
es ribirse). Lo que apare en entre or hetes, signi a que es op ional.
91
Ej:
enum dia_sem = {
dom, lun, mar, mie, jue, vie, sab };
La de lara in anterior dene un nuevo tipo de dato, aunque C toma sus valores
omo enteros. Las onstantes simbli as de una enumera in toman valores por omisin
(default) omenzando desde ero (0). Es posible denir el valor de ada onstante o
dar el valor de la primera y as las dems toman valores subsiguientes.
Ej:
enum dia_sem = {
dom=1, lun, mar, mie, jue, vie, sab };
Las deni iones de estru turas pueden introdu ir nuevos nombres de tipos. A modo
de ejemplo, la siguiente de lara in
stru t person {
int id;
har name[31;
unsigned short age;
};
dene el tipo
stru t Person.
typedef type name; dene un nuevo nombre (sinnimo) de un tipo.

typedef stru t person Person; dene el tipo Person omo
7
alias del tipo stru t person .
La senten ia
A modo de ejemplo,
un sinnimo o
5.14. Fun iones

La deni in de una fun in tiene la forma
return_type fun tion_name(arguments ) body

arguments es una lista de argumentos de la forma type id, separados por
oma o void en el aso de una fun in sin argumentos. Los pro edimientos deben usar
void omo tipo de retorno.
donde
El uerpo de una fun in es una senten ia de bloque.

En las expresiones pueden apare er invo a iones a fun iones, las uales toman la
forma
f(arg1 , ..., argn ),
donde
f es
el nombre de una fun in.
En el aso que la fun in no tenga argumentos se invo ar omo

La senten ia
return expression
f().
en el uerpo de una fun in, naliza su a ti-
va in, retornando el valor denotado por expression. En el aso de pro edemientos

(fun iones on tipo de retorno
void), la expresin se omite.
Cuando se al anza el nal del bloque que onstituye el uerpo de una fun in se
eje uta un
7 Los
return impl ito.
smbolos person y Person son diferentes, ya que C distingue mays ulas de mins ulas.
92
Las fun iones pueden tener un nmero variable de argumentos, los uales se denotan
on . . . (tres puntos seguidos). Esto permite denir fun iones omo por ejemplo
printf,
uyo perl es
int printf( onst har * format, ...)
va_list) y fun iones (va_start,va_arg,va_end)
La bibliote a estndar de C provee tipos de datos (

para a eder a los argumentos.
Las fun iones omo
printf se basan en el primer argumento (format) para a eder
y manipular los restantes argumentos.

El soporte de un nmero variable de argumentos, es a razn por la ual mu has
implementa iones de C pasan (apilan) argumentos de dere ha a izquierda, lo que permite que el primer argumento se a eda on un desplazamiento onstante dentro del
registro de a tiva in orrespondiente. sta k) de una fun in que a epte un nmero
variable de argumentos. fun in (q
5.15. Al an e de las de lara iones

Una de lara in en el ambiente global se denomina una de hara in global y las
entidades (variables, onstantes, . . . ) se denominan globales.
Un bloque en la deni in de una fun in C onsta de dos partes: al omienzo
puede ontener de lara iones y luego puede ontener senten ias yo omandos. No se
puede pueden mez lar de lara iones y otras senten ias.
Las de lara iones ontenidas en un bloque senten ia { . . . } , tienen al an e lo al
al bloque, es de ir que fuera del bloque las entidades de laradas no pueden ser referen iadas.
El ejemplo 5.4 muestra de lara iones lo ales y globales en un programa. La variable g es global, es de ir que puede referen iarse en ualquier parte del programa. La
variable lo al y el parmetro formal p son lo ales en la fun in f. La variable x es
slo visible dentro del bloque mas interno.
Esta separa in de mbitos o ambientes es de gran ayuda para modularizar programas, permitiendo que slo se de laren variables en los mbitos donde son ne esarios,
sin permitir el a eso en mbitos que no deberan ono er de su existen ia.
Las de lara iones globales (variables, onstantes y fun iones) pueden ser usadas en
un mdulo externo ( liente) mediante de lara iones extern.
Una de lara in externa ha e referen ia a una entidad que ha sido denida en otro
mdulo. Ejemplo:
extern void sta k_push(Sta k * s, int item);
Una de lara in global que se quiera ha er visible slo en el mdulo orriente (ar hivo fuente), deber ser pre edida por stati .
Las de lara iones de tipos no se pueden ha er externas, es de ir que en un ar hivo
que se quiera referen iar a un tipo de dato, se deber in luir su deni in, ya sea
93
int g;
/* variable global */
int f(float p)
{
har ;
/* es una variable lo al a la fun ion f */
...
{
int x;
}
g++;
x = 1;
/* x es lo al a este bloque */
/* aqu pueden referen iarse todas las variables */
/* ERROR, x no existe en este ambito */
Figura 5.4: Ejemplo de de lara iones lo ales y globales
es ribiendo la deni in o in luyendo un ar hivo de abe era (.h) que la ontenga.

En la se in 5.22 se des ribe la modulariza in de programas C.
5.16. Tiempo de vida de las entidades

Las variables, omo entidades que requieren alma enarse en la memoria prin ipal
de la omputadora, tienen aso iado un tiempo de vida, es de ir un intervalo de tiempo
entre su rea in y su destru in.
Es razonable que el tiempo de vida de una variable global sea desde el momento en
que el programa se ini ia (se onvierte en un pro eso del sistema) hasta que el mismo
nali e. Es de ir que una variable global tiene un tiempo de vida que se orresponde
on el tiempo de eje u in del programa.
En general, los valores de las variables globales se alma enan en una rea de memoria estti a la ual se reserva al omienzo del programa y al nalizar se libera.
Por el ontrario, las variables lo ales a un bloque no tendra sentido que estn
presentes en la memoria uando la fun in a la ual perten en no est a tiva, es de ir
no est siendo eje utada (ha sido invo ada ) a tualmente.
Cuando una fun in retorna (naliza su a tiva in) sera razonable que todas las
entidades de laradas lo almente sean destruidas, es de ir liberada la memoria en donde
se alma enaban sus valores, lo ual permitira reutilizar esas reas de memoria para
ontener valores de otra posible fun in a a tivarse.
Este es el omportamiento normal de las variables lo ales y de los parmetros
formales de una fun in. Esta es la razn prin ipal por lo que los lenguajes de este
tipo ( on diferentes ambientes), manejen a la memoria donde se alma enan los valores
94
para las variables lo ales y parmetros formales omo una estru tura de pila (sta k ) .
Cuando una fun in es invo ada, se rea (reserva) en la memoria (tope de la pila)
un registro de a tiva in, el ual ontiene su iente espa io para ontener los valores
de sus parmetros formales y sus variables lo ales .

Cuando una fun in retorna (se eje ut una senten ia
return o se al anz el nal
del bloque prin ipal de la fun in), el registro se destruye por lo que las variables lo ales y los parmetros formales desapare en.
5.16.1. Cambiando el tiempo de vida de variables lo ales

En C, la palabra reservada
stati indi a, en una de lara in lo al que las entidades
apare iendo en la de lara in permanez an vivas luego del retorno de la fun in.
De todos modos di has entidades no pueden ser referen iadas fuera de su bloque
orrespondiente, es de ir que su al an e no es modi ado, pero sus valores permane en
en la memoria para poder reutilizarse en la prxima a tiva in de ese bloque.
Estas variables generalmente no se alma enan en la pila (sta k), sino que se reserva espa io en el rea de memoria estti a en donde se alma enan las entidades globales.
Cabe ha er notar que stati tiene do signi ados diferentes:
Cuando se apli a a de lara iones globales afe ta a su visibilidad, es de ir que

signi a que no se exporta (no es visible fuera del mdulo).
Cuando se apli a a variables lo ales, afe ta a su tiempo de vida.
5.17. Operadores
Los denominados operadores de un lenguaje de programa in son la base de la
forma in de las expresiones. Entre ellos generalmente en ontramos operadores aritmti os, rela ionales, lgi os, et .
Un operador puede estar denido omo injo (ej:
( ej:
x < y ),
prejo (ej:
x)
o sujo
x + +).
La siguiente tabla muestra algunos de los operadores de C:
8 Una estru tura de pila tiene una polti a LIFO (Last In First Out, el ltimo en entrar es el
primero en salir).
9 Adems el mismo registro de a tiva in puede usarse para alma enar valores temporarios durante
la evalua in de alguna expresin.
95
Aritmti os
Des rip in
adi in de enteros y reales (injo)
substra in de enteros y reales (injo)
multipli a in de enteros y reales (injo)
divisin de enteros y reales (injo)
resto (modulo) de enteros (injo)
Manipuladores de bits
Des rip in
<<
>>
dezplazamiento a izquierda de bits (injo)
or (bit a bit, injo)
&
and (bit a bit, injo)
Rela ionales
Des rip in
==
igual (injo)
!=
distinto (injo)
<
menor (injo)
>
mayor (injo)
<=
menor o igual (injo)
>=
mayor o igual (injo)
Lgi os
Des rip in
||
or (injo)
&&
or (injo)
not (prejo)
dezplazamiento a dere ha de bits (injo)
5.17.1. Asigna in
C es un lenguaje on un onjunto de senten ias de asigna in muy ri o, a diferen ia
de otros lenguajes que slo ontienen unas po as o una ni a senten ia de asigna in.
En el modelo de la programa in imperativa la asigna in es generalmente la ni a
senten ia que reamente produ e una omputa in efe tiva, ya que es la ni a senten ia
que realiza un ambio de estado durante la eje u in de un programa.
Otro aso en donde se produ e un ambio de estado es en el pasaje de parmetros,
lo que se ver mas adelante.
En C las senten ias de asigna in son expresiones (operadores), es de ir que a su vez

denotan un valor, lo que permite al programador realizar omposi in de asigna iones.
A ontinua in se muestra una tabla on algunos de los operadores de asigna in
en C:
96
Operador
Des rip in
asigna in (ej: x = y + 1)
+=
a umula in (ej: x += y es equivalente a x = x + y)
-=
(ej: x -= y es equivalente a x = x - y)
*=
(ej: x *= y es equivalente a x = x * y)
/=
(ej: x *= y es equivalente a x = x / y)
%=
(ej: x %= y es equivalente a x = x % y)
x++
pos-in remento (ej: x = y++; asigna y a x y luego in rementa y)
x
pos-de remento
++x
pre-in remento (ej: x = y++; in rementa y, luego asigna y a x)
x
pre-de remento
5.17.2. Expresiones ondi ionales

Una expresin ondi ional permite denotar un valor el ual ser omputado dependiendo de una ondi in.
En C una expresin ondi ional sigue el siguiente esquema sint ti o:
( < ondi in> )? <expr1> : <expr2>

la ual signi a que si la ondi in evala a verdadero, arroja el resultado de la
evalua in de expr1, sino arroja el resultado de la evalua in de expr2.
Ejemplo:
x = ( y > 0 )? y+1 : z;
5.17.3. Otras expresiones

En C las expresiones pueden ontener onstantes, variables, operadores y llamados
a fun iones, estas ltimas, ya sean que se en uentren en la bibliote a estndar o que
sean denidas en el mismo programa.
Ejemplo de una expresin:
a = x = ( y > 0 )? y+1 : f(z) * 2;
5.18. Senten ias de ontrol: omandos

Los omandos afe tan al ujo de eje u in del programa. El lenguaje C ontiene
senten ias de ontrol estru turados, es de ir que las senten ias tienen una semnti a
de ontrol espe i ado, por lo que el ontrol de ujo (saltos) estn impl itos
10 .
Las senten ias de ontrol ontrol de ujo, generalmente se lasi an en senten ias
se uen iales, ondi ionales, iterativas y otras.
10 Aunque
C mantiene el omando
goto L;
el ual realiza un salto expl ito.

97
5.18.1. Se uen ia
La senten ia que estable e que sus omponentes deben eje utarse en se uen ia es
la senten ia de bloque que ya se ha visto on anterioridad.
Tanto las de lara iones omo los omandos que deben ir a ontinua in se eje utan
en forma se uen ial de arriba ha ia abajo.
Existen senten ias las uales pueden ontener otras senten ias. Generalmente, las
reglas sint ti as son que ontienen una senten ia (la ual puede ser un bloque).
5.18.2. Senten ias ondi ionales

Una senten ia ondi ional permite eje utar diferentes grupos de senten ias en base
a una ondi in dada.
En C en ontramos dos tipos de senten ias: la senten ia
if
y la senten ia
swit h. La
primera permite eje utar senten ias en base al valor de verdad de una ondi in dada
(expresin booleana), mientras que la segunda permite eje utar diferentes senten ias
dados diferentes asos determinados por el valor de una expresin.
El esquema sint ti o de la senten ia
if
es la siguiente:
if ( < ondi in> )

<senten ias por verdadero>
else
<senten ias por falso>
donde la lusula else es op ional.
Un ejemplo:
if ( x == y ){
x = y * z;
...
}
else
x = y;
El esquema sint ti o de la senten ia
swit h es la siguiente:
swit h ( < ondi in> ) {

ase <valor1>: <senten ias aso 1>
break;
ase <valor2>: <senten ias aso 2>
break;
default:
<senten ias por ninguno de los valores anteriores>
}
98
donde la lusula default es op ional y los valores valor1, valor2, . . . , deben ser
onstantes de tipo entero.
Si en ada aso se omite la senten ia
break,
la eje u in ontinuar on las sen-
ten ias del aso siguiente, si hubiera.

Ejemplo:
swit h ( x-y ) {
ase 5: x = y - 1;
break;
ase 8: y = z;
break;
}
5.18.3. Senten ias de itera in

Las senten ias e itera in permiten que un onjunto de senten ias sean eje utadas
en forma repetitiva.
5.18.3.1. Itera in denida

Una senten ia de itera in denida expresa que se debe repetir la eje u in de su
uerpo un nmero determinado de ve es. La ni a senten ia de este tipo en C es el
for.
A ontinua in se da el esquema sint ti o del
for:
for ( <ini ializa in> ; < ondi in>; <paso> )

<senten ia>
La semnti a del
for
es: se eje uta la ini ializa in, luego se veri a la ondi in,
si es verdadera, se eje uta su uerpo (senten ia ), nalmente se eje uta el paso y se

repite el i lo a partir de la veri a in de la ondi in.
La senten ia
for de C en una de las mas ompli adas de des ribir ya que tanto en
la ini ializa in omo en la ondi in y en el paso, pueden es ribirse una se uen ia de

expresiones arbitrarias separadas por oma, lo que la onvierte, en realidad, en una
senten ia de itera in indenida, rigurosamente hablando.
Tambin es posible que los tres omponentes estn va os. Una ondi in va a es
evaluada a verdadero.
Se a onseja, por razones de legibilidad y para evitar errores, utilizarla al estilo de
senten ias
for omo se en uentran en otros lenguajes, omo por ejemplo, Pas al.
Ejemplo:
for (i=0; i<N; i++)

x += i;
99
5.18.3.2. Itera in indenida

C ofre e dos senten ias de itera in indenida.
La senten ia
while y la senten ia do . . . while.
A ontinua in se muestran los esquemas de su sintaxis:
while ( < ondi ion> )

<senten ia>
y
do {
<senten ia>
} while ( < ondi ion> );
while) evala la ondi in y si arroja verdadero, se eje uta su uerpo.

do . . . while, primero eje uta su uerpo para luego evaluar su ondi-
La primera (
La segunda
in. Mientras la ondi in evale a verdadero, se ontinuar eje utando el uerpo.

Se debe notar que la primera permite eje utar su uerpo ero o ms ve es, mientras
que la segunda permite eje utarlo uno o ms ve es.
ejemplos:
while ( x > 0 ) {
a = 1;
b = 2 * x;
}
...
do {
x++;
y--;
} while ( x < 100 && y > 10);
5.19. Tipos de datos estru turados

Adems de los tipos bsi os vistos en el aptulo anterior, el lenguaje C permite
denir tipos de valores estru turados, es de ir que son ole iones o agrupa iones de
otros datos.
5.19.1. Arreglos
Un arreglo es una estru tura homognea
11 del elementos alma enados en forma
ontiga en la memoria.
Si bien algunos lenguajes permiten denir arreglos de ms de una dimensin, C
slo permite denir ve tores (arreglos de una dimensin).
11 Es
de ir que todos sus omponentes don del mismo tipo.

100
Esto en general no es un problema ya que un arreglo multidimensional se puede

simular on ve tores de ve tores, es de ir deniendo un ve tor donde ada uno de sus
elementos es otro ve tor.
Un ve tor en C se dene de la siguiente manera:
<type> ve [N;
donde <type> es algn tipo bsi o o estru turado y N es una onstante o variable
de tipo entero, la ual dene su dimensin (el nmero de omponentes). El siguiente
ejemplo dene una ve tor de 10 reales en punto otante de doble pre isin:
double ve [N;
Cuando se de lara un ve tor en un parmetro formal de una fun in, su dimensin
se omite.
Se debe notar que la dimensin de un ve tor puede denirse en tiempo de eje u in,
ya que C permite que sea una variable y su valor en un momento espe o slo puede
ser determinado durante la eje u in. Otros lenguajes ( omo FORTRAN 77 o Pas al
estndar) requieren que su dimensin sea determinada en tiempo de ompila in por
lo que requieren que sea una onstante.
Si bien su dimensin puede determinarse dinmi amente (tiempo de eje u in),
una vez reado, un ve tor no puede ambiar su dimensin. Los ve tores de este tipo
se ono en omo semidinmi os.
Cada elemento de un ve tor se puede a eder por medio de su ndi e en el ve tor. El
ndi e es una espe ie de identi ador (o nombre) unvo o de ada elemento. El primer
elemento de un ve tor tiene ndi e 0 ( ero) y el timo
N 1, (donde N
es si dimensin).
Es responsabilidad del programador no intentar a eder a elementos on un ndi e

invlido. Si este fuese el aso, estaramos ante la presen ia de un a eso fuera de rango
(out of bound). C no dete ta durante la eje u in los a esos fuera de rango, por lo
que si esto su ediera el programa puede ontinuar su eje u in aunque seguramente
realizar omputa iones no esperadas.
El siguiente ejemplo muestra la deni in y uso de un ve tor:
#in lude <stdio.h>

#define N 100
/* returns the sum of elements of ve tor v */
double sum_ve tor( onst double v[)
{
int i;
double sum = 0.0;
for (i=0; i<N; i++)
sum += v[i;
101
return sum;
void main(void)
{
double ve tor[N;
/* definition of ve tor v */
/* initialization of ve tor ... TO DO */

}
printf("Suma=%10.2d\n", sum_ve tor(ve tor));

Es posible de larar una matriz (arreglo de dos dimensiones) adi ionando la otra
dimensin en la de lara in. Ejemplo:
double v[N[M;
lo ual de lara un ve tor de dimensin N, en el ual, ada elemento es un ve tor de
M elementos. Esto se puede ver omo una matriz de
N xM
(N las por M olumnas).
Lo anterior se extiende para denir arreglos multidimensionales.

El siguiente ejemplo muestra la deni in y la ini ializa in de una matriz:
#in lude <stdio.h>

#define N 10
#define M 20
void main(void)
{
double ve [N[M;
int i,j;
for (i=0; i<N; i++)

for(j=0; j<M; j++)
ve [N[M = 0.0;
5.19.2. Estru turas

Las estru turas (o registros) se ara terizan por ser ontenedores heterogneos,
es de ir sus omponentes pueden ser de distinto tipo. Generalmente se utilizan para
des ribir propiedades de entidades.
Sus omponentes de denominan ampos (elds) y se a ede a ada uno de ellos por
su identi ador (nombre del ampo).
El siguiente ejemplo muestra la deni in y uso de una estru tura:
...
stru t persona {
unsigned long dni;
/* de lara ion del tipo stru t persona */
102
har nombre[31;
unsigned short edad;
};
stru t persona p;
/* p es una variable de tipo stru t persona */
...
p.dni = 24456789;
p.edad = 31;
...
/* asigna ion de valores a ampos ... */
5.19.3. Uniones disjuntas

Una unin disjunta (o variante) permite denir ampos que slo uno de ellos es
vlido en un determinado momento en la eje u in de un programa.
Son tiles para a eder o ver un dato de diferentes formas.
Si uno de sus ampos se modi a, los dems tambin, ya que en realidad se est
reriendo al mismo valor, es de ir en la memoria se ha reservado tanto espa io omo
requiere su omponente de mayor tamao en su representa in.
A modo de ejemplo, a ontinua in se muestra un aso en que es posible a eder a
ada byte de un entero de 32 bits, lo ual servira para ver mo es su representa in
en memoria:
union u {
int value;
unsigned har bytes[4;
};
u rep_int;
...
...
rep_int.value = -1;
for (i=0; i<4; i++)
printf("byte[i=%d%n", rep_int.bytes[i);
Como se puede apre iar en el ejemplo, los ampos de una unin se a eden de la
misma manera que los de una estru tura.
5.20. Punteros
Los punteros son datos bsi os del lenguaje. Sus valores representan dire iones de
memoria de otras entidades (variables o valores). El tipo de datos puntero es un tipo
parametrizado ya que son tipados, esto es, un puntero apunta a entidades de un tipo
103
determinado.
La sintaxis de la de lara in de un puntero tiene la forma
tipo de los valores apuntados por el puntero
ptr.
T * ptr,
donde
es el
Los punteros tienen dos operdores aso iados:
referen ia in (operador &) : el operador prejo & apli ado a una variable, retorna su dire in de memoria, la ual puede ser asignado a pun puntero de un
tipo ompatible on di ha variable.
desreferen ia in (operador *) : el operador (prejo)

retorna el valor apuntado por
p.
apli ado a un puntero
El siguiente ejemplo muestra el uso de punteros:
...
{
int v = 5; int * p1 = &v;
int p2;
p2 = p1;
/* asigna ion ( opia) entre punteros */
(*p1)++;
/* el valor de v es in rementado (6) */
printf("El valor de v es: %d\n", *p2);
}
...
5.20.1. Ve tores y punteros

Como ya se vio anteriormente, C permite denir ve tores semidinmi os, es de ir
que su dimensin puede determinarse en tiempo de eje u in. Esto trae algunos problemas de representa in ya que el ompilador no podra generar digo para reservar
espa io en la memoria ya que no ono e la antidad de memoria requerida en tiempo
de ompila in.
Una implementa in posible es ha er que un ve tor est des ripto en tiempo de
eje u in por un puntero a su dire in base (su primer elemento). Con el n de onseguir e ien ia y simpli idad, di ho des riptor no ontiene informa in en runtime
sobre su dimensin, por lo ual el manejo de los ve tores (y no a eder a elementos
fuera de rango), queda bajo la total responsabilidad del progamador.
A ontinua in se muestra un fragmento de programa de ejemplo ilustrando una
situa in on ve tores semidinmi os.
...
int avg(float v[, int dim)
{
int i; float a um = 0.0;
104
for (i=0; i<dim; i++)

a um += v[i;
return a um / dim;
}
...
{
float ve [N;
a = avg(ve ,N);
...
El programa de arriba mere e algunas a lara iones.
la de lara in del parmetro formal
float v[ es equivalente a float *v.
la dimensin del parmetro a tual tiene que ser pasado omo parmetro, ya que
el parmetro formal no tiene informa in sobre su dimensin.
La gura 5.5 muestra una forma posible de representa in de la memoria de la
de lara in de la forma
T v[N.
v[0]
v[1]
v[N1]
Figura 5.5: Representa in en memoria de un ve tor (en el sta k).
El programa siguiente es equivalente al programa anterior.
...
int avg(float *v, int dim)
{
int i; float a um = 0.0;
105
for (i=0; i<dim; i++)

a um += *(v+i);
return a um / dim;
}
...
{
float ve [N;
a = avg(ve ,N);
...
Un anlisis de este ltimo programa muestra que:
la expresin
v[i es equivalente a (*v)+i.
es posible realizar opera iones aritmti as sobre punteros.

La aritmti a sobre punteros no es equivalente a la aritmti a sobre enteros. Los
arreglos tienen en la memoria una representa in ontiga. El puntero
dire in base. Podra pensarse que la expresin
nada en
v.
Si fuera as, la expresin
*(v+i)
v+1 suma uno a
apunta a su
la dire in alma e-
se refererira a un valor on la dire in
base del ve tor mas uno, lo ual no sera una referen ia a un valor del ve tor, ya
que un entero generalmente se representa en ms de un byte (es omn que en una
arquite tura de 32 bits se represente en 4 bytes).
v+i debera signi ar, en aritmti a de

address(v)+i*sizeof(int), es de ir, la suma de la dire in base de v on
valor de i multipli ado por el tamao (en bytes) de la representa in del tipo base
Este ejemplo muestra que la expresin
enteros,
el
del puntero.
Efe tivamente la aritmti a de punteros tiene en uenta el tamao de su tipo base.
El programa anterior podra re orrer el ve tor utilizando solamente punteros, tal omo
se muestra a ontinua in.
...
int avg(float *v, int dim)
{
int *p; float a um = 0.0;
for (p=v; p < v+dim; p++)
a um += *p;
return a um / dim;
}
...
{
float ve [N;
a = avg(ve ,N);
...
106
}
Esto muestra que hay una rela in muy estre ha on los ve tores y punteros.
Una variable de tipo ve tor de elementos de tipo T se representa omo un bloque
ontigo de elementos de tipo T mas un puntero ( onstante) a la dire in base
del bloque.
La diferen ia entre un puntero y una variable de tipo ve tor es que la variable es
un puntero onstante, es de ir, que no puedo modi ar su dire in base, uando
un puntero omn es modi able.
Esta de isin de representa in tiene sus ventajas y desventajas. Como ventajas
podemos men ionar su simpli idad y e ien ia tanto en representa in omo en a eso
a omponentes. Como desventajas es f il de ver que al no disponer de la dimensin
en el des riptor de un ve tor, su manejo queda bajo la total responsabilidad del programador.
Esto es in onveniente, ya que las fun iones que toman omo parmetros ve tores,
su de lara in en s no es lara (ej: f(int *v) /* es un puntero o un ve tor? */). Los
strings, que son ve tores de tipo
har, sufren
estas mismas onse uen ias.
Los strings, al ser ve tores, no son tratados omo los tipos bsi os, esto es, no pueden asignarse (se tiene que ha er elemento a elemento) y generalmente es se manipulan
mediante fun iones de bibliote a (ver la interfa e del ar hivo de abe era
string.h.
Otra desventaja de este manejo de los ve tores es que los programadores novatos
en el lenguaje a menudo se onfunden que la de lara in de un puntero dene un ve tor.
La representa in de los ve tores de C es mu has ve es la ausa de problemas de
seguridad en mu has apli a iones de red, omo lo son los ataques por desborde de
buers (buer-overow) que se basan en ha er que ierto digo del programa opia
datos fuera del rango de algn arreglo.
Esto permite desarrollar t ni as de inye in de digo.
5.20.2. Punteros a fun iones

Una fun in
de la forma
T f(args) tiene
el tipo
T (*f)(args).
Esto signi a que el nombre de una fun in es un puntero ( onstante), lo que permite usar a los nombres de las fun iones omo valores en expresiones (involu rando
punteros).
A ontinua in se muestra un ejemplo del uso de punteros a fun iones.
...
int square(int n)
{
return n*n;
}
107
int main(void)
{
int (*ptr_square)(int) = square;
int sq;
sq = ptr_square(5);
...
5.21. Manejo de memoria dinmi a

C no tiene in orporado nativamente en el lenguaje operadores para el manejo de
memoria dinmi a (heap). El heap es manipulado por fun iones de la bibliote a estndar, uya interfa e est denida en el ar hivo de abe era
mallo .h.
La bibliote a estndar del lenguaje provee dos fun iones para manipula in de
variables heap.
Reserva de bloque (allo ation) : la fun in
void * mallo (size_t s) reserva un

size_t generalmente
bloque y retorna un puntero a su dire in base (el tipo

est denido omo
unsigned int).
Libera in de un bloque (deallo ation) : la fun in

bloque apuntado por el puntero
p.
void free(void p)
libera el
El siguiente programa muestra un ejemplo de su uso.
int *p = (int *) mallo (sizeof(int));

float *ve = (float *) mallo (sizeof(float));
...
ve [i = ...;
free(ve );
free(p);
Cabe notar que, omo la fun in
mallo retorna
un puntero a
void,
es ne esario
ha er un ambio de tipo ( ast) para que el ompilador, al hequear los tipos no reporte
un error.
12
5.22. Estru tura in de programas: mdulos

Cuando se es riben programas grandes, stos generalmente se des omponen estru turalmente en mdulos. Un mdulo generalmente dene una interfa e, la ual ontiene
12 Notar que no es ne esario onvertir un puntero de tipo T a un puntero a void, pero s a la inversa.
Esto muestra que el tipo void representa un tipo unin de todos los tipos denibles.
108
de lara iones de sus omponentes y los exporta al exterior para otros mdulos que lo
usen ( lientes).
Un mdulo ontiene una des rip in de su interfa e y su implementa in. Algunos
lenguajes ofre en onstru iones sint ti as para la deni in de mdulos ( lases de
Haskell, Units de obje t Pas al o Delphi, et ).
El lenguaje C no ofre e ninguna sintaxis para la deni in de mdulos. Un mdulo se orresponde on una unidad de ompila in (ar hivo objeto o bibliote a). Un
mdulo que requiera a eder a omponentes de otro mdulo, deber de lararlos antes
de su uso. Esas de lara iones debern ser pre edidas por la palabra reservada
extern,
lo ual le di e al enlazador (linker) que las deni iones de esos omponentes (tipos,
variables, onstantes o fun iones) no estn en el mdulo orriente, sino que estn en
otro mdulo (el ual deber ser in ludo en los respe tivos omandos de ompila in o
enlazado).
La onven in usada en programas C es que las de lara iones de los omponentes
que exporta ada mdulo se in luyen en un ar hivo de abe era, on sujo
.h.
Estas
de lara iones se denen omo externas ya que su nalidad es la de ser in luidas en los
mdulos lientes.
La implementa in de un mdulo se es ribe en un ar hivo on sujo
. .
Uno de los in onvenientes de este esquema, el ual se basa simplemente en la in lusin textual de digo, es que un ar hivo de abe era podra in luirse ms de una vez
en un mdulo
13 y podran produ irse errores de omplila in por mltiples de lara io-
nes o deni iones de los mismos identi adores. Para evitar esto, la pr ti a habitual
es proteger a ada ar hivo de abe era on dire tivas del prepro esador para dete tar
y evitar de lara iones repetidas.
La dire tiva
#ifndef symbol <body>#endif,
expande su uerpo slo si
symbol
est denido. Por lo tanto un patrn omnmente utilizado en los a hivos de abe era
es
#ifndef S
#define S
/* de larations */
#endif
A ontinua in se muestra un ejemplo de un ar hivo de abe era (interfa e).
/* File: list.h */
#ifndef LIST_H
#define LIST_H
13 El ar hivo f1.h podra in luir a f2.h y el programador podra in luir expl itamente ambos en
otro ar hivo de abe era.
109
typedef stru t n {
int value;
stru t n * next;
} list_node;
typedef stru t {
list_node * first, * last;
int items;
} list;
extern list * list_new(void);
extern void * list_insert(list *l, int value, int pos);
...
#endif
La implemena in se muestra a ontinua in.
/* File: list. */
#in lude <mallo .h>
typedef stru t n {
int value;
stru t n * next;
} list_node;
typedef stru t {
list_node * first, * last;
int items;
} list;
list * list_new(void)
{
list * result = (list *) mallo (sizeof(list));
result->first = result->last = NULL;
result->items = 0;
return result;
}
void * list_insert(list *l, int value, int pos)
{
...
}
/* Auxiliar fun tion (see stati modifier) */
stati list_node * goto_pos(list *l, int pos)
{ ...
110
Captulo 6
Manejo de la memoria
En este aptulo se des ribirn los me anismos mas omnmente utilizados en la
implementa in e iente del manejo de la memoria de los lenguajes de programa in.
6.1. Manejo de la memoria e iente

El modelo de eldas presentado es ade uado para dar una semnti a abstra ta de
un modelo on estado mutable (statefull) el ual ontiene tres tipos de memoria diferentes: una pila, la ual sirve omo estru tura de ontrol para el ujo de eje u un de
los programas, la memoria de valores
y la memoria de eldas
La arquite tura dominante de hardware sigue el modelo Von Newmann, el ual

permite que tanto los datos omo las instru iones del programa se alma enen en la
misma memoria de a eso dire to (RAM).
La mayora de los ompiladores e intrpretes de lenguajes de programa in modernos realizan un manejo de la memoria de manera muy e iente. El manejo de la
memoria que se des ribe a ontinua in se adapta a lenguajes de distintos paradigmas
y estru turados a bloques .

Un pro eso (programa en eje u in) tiene los siguientes bloques de memoria asignados. Estos bloques no estn ne esariamente ontigos.
La gura 6.1 muestra la representa in de un pro eso en memoria. Un pro eso
onsta de varios segmentos o reas.
Segmento de digo (text segment): ontiene las instru iones del programa, es
de ir, el digo del programa prin ipal y de sus subrutinas.
Segmento de datos: rea de alma enamiento de las variables globales (y variables
lo ales estti as en C o C++).
1 Un lenguaje estru turado a bloques ontiene onstru iones sint ti as (bloques) on sus propios
ambientes. Los bloques pueden ser anidadas y ada bloque interno hereda el ambiente de su bloque
ontenedor.
111
process memory
heap
CPU registers
Flags
stack
Stack Pointer
Frame Pointer
Program Counter
static data
others...
code segment
Figura 6.1: Representa in en memoria de un pro eso.
Sta k: rea de alman enamiento en las que se lleva el ontrol de las a tiva iones
de las subrutinas (dire iones de retorno) y en la mayora de los lenguajes de
programa in modernos se lleva informa in de ontrol adi ional para a eso
a ambientes lo ales y no lo ales y adems se alma enan las variables lo ales y
valores de los parmetros a tuales de las subrutinas a tivas.
En ada invo a in a una subrutina se onstruye un registro de a tiva in. En
ada retorno de una fun in el registro de a tiva in del tope se elimina dejando
en el tope en el estado anterior a la invo a in (su invo ante).
Mas abajo de des ribe en mas detalle el manejo del sta k.
Heap: mantiene bloques de memoria que representan datos del programa reados dinmi amente, esto es, reados por opera iones del tipo new (de Pas al,
C++, Java, et ), mallo de C o valores reados impl itamente omo el lenguaje
utilizado aqu o lenguajes fun ionales omo Haskell o ML.
Los bloques del heap son liberados expl itamente (opera iones omo delete, free,
dispose, . . . ) o impl itamente por un me anismo de re ole in de basura, omo

se des riben ms adelante.
6.2. Manejo del sta k

En los primeros lenguajes de programa in, omo FORTRAN 77 y COBOL, el
sta k slo se utiliz para llevar el ontrol de invo a iones y retornos de rubrutinas.
El sta k slo ontena dire iones de retorno que eran salvadas por una instru in
de salto a una subrutina (instru iones assembly JSR S o CALL S ), la ual ontiene
un operando que orresponde a la dire in de memoria de la primera instru in de
la subrutina invo ada. La instru in apila (push) automti amente el ontenido del
112
program ounter
2 en el sta k y lo modi a on la dire in del operando. De esta forma
el ontrol pasa a la subrutina destino.

Cuando en la subrutina se eje uta una instru in de retorno (RET ), sta automti amente desapila (pop) el ontenido del tope del sta k y lo opia al program
ounter, por lo que la eje u in del programa ontina on la instru in siguiente a

la invo a in.
La estru tura de datos de pila permite que los retornos se produz an de una manera
last all- rst returned.

En la jerga de arquite turas de omputadoras la pila se denomina system sta k.
Los lenguajes men ionados arriba alma enaban los valores de las variables del programa en un rea estti a ( uyo tamao se al ulaba en tiempo de ompila in). En
esa rea estti a se mantenan tanto los valores de las variables globales y las variables
lo ales y parmetros de las subrutinas.
SUBROUTINE S1(X,Y)
INTEGER X,Y,Z
...
END
x
y
Z
SUBROUTINE S2(X)
REAL R; INTEGER X
...
END
...
PROGRAM P
CHARACTER S(4)
...
END
X
R
S(0)
S(1)
S(2)
S(3)
Figura 6.2: Manejo de la memoria estti a en FORTRAN 77.

La gura 6.2 muestra un ejemplo del manejo de la memoria estti a implementada
en los ompiladores de FORTRAN 77 y anteriores.
El manejo de memoria en COBOL era an mas simple ya que las subrutinas no
soportan parmetros.
Este manejo, si bien es muy simple y e iente, no permite re ursin, lo ual es
prohibitivo en la implementa in de lenguajes de programa in modernos.
Como ventaja se puede men ionar que las variables lo ales de las subrutinas mantenan su valor entre las invo a iones, por lo que los programadores mu has ve es ha an
2 El
ual ontiene la dire in de la siguiente instru in a la orriente en eje u in.

113
uso de esa ara tersti a.

En la mquina abstra ta para el lenguaje utilizado aqu el uso del sta k permite
realizar la tarea des ripta arriba y adems llevar el ujo de eje u in de ada instru in, lo ual abstrae el program ounter, ya que la mquina no ontiene registros
omo las arquite turas onven ionales. Esta abstra in es ade uada para des ribir la
semnti a de las senten ias del lenguaje pero es obvia una implementa in e iente
utilizando una arquite tura onven ional moderna.
Los lenguajes modernos, mu hos de los uales son estru turados a bloques y permiten re ursin, slo ha en manejo estti o de la memoria para las variables globales
y ha en uso del sta k no slo para el ontrol de invo a in y retornos de subrutinas,
sino que adems se aprove ha para alma enar los ambientes lo ales (variables lo ales
y valores de los parmetros a tuales).
Esto ha e que el sta k se onvierta en una estru tura heterognea, es de ir que sus
elementos sean re ords de tamao variable por lo que es ne esario llevar un puntero
(link) en ada registro que apunte a una dire in base del registro inmediato anterior.
Esto implementa un sta k omo una lista enlazada.
Este puntero generalmente se denomina dynami link. Tambin es ne esario disponer de un puntero a una dire in base del registro de a tiva in orriente (registro del
tope del sta k) para el a eso a los diferentes omponentes dentro del registro, omo
las variables lo ales o parmetros.
La dire in base al registro de a tiva in orriente generalmente se mantiene en un
registro de la CPU reservado on ese n. La mayora de las CPUs orrientes ontienen
un registro espe ial para este propsito, generalmente denominado frame pointer o
base pointer 3 .
La gura 6.3 se muestra el formato de un registro de a tiva in.

Se puede notar que el registro tambin se puede utilizar para alma enar valores
retornados por las rutinas que representan fun iones, aunque en algunos lenguajes se
asume que los valores se retornan en un registro de la CPU. Esto ltimo impone que
las fun iones slo puedan retornar valores de tipos bsi os (numri os, ara teres, et )
o punteros a valores estru turados. Esto se da en lenguajes omo C o Java.
Un registro de a tiva in se forma en una se uen ia de pasos durante en una invo a in en la ual ooperan el invo ante y la rutina invo ada:
1. El invo ante reserva lugar para el valor retornado por la rutina (slo en aso que
sea una fun in).
2. El invo ante apila los valores de los parmetros a tuales.
3. El invo ante eje uta la invo a in (ej: instru in CALL S). El ontrol pasa a la
primera instru in de la subrutina.
4. La subrutina salva en el sta k (apila) el valor del frame pointer (tambin denominado dynami link ) para poder restaurarlo en el retorno. El frame pointer se
3 En
la arquite tura Intel IA32, utilizada en la mayora de las PCs a tuales el registro usado es el
Base Pointer (EBP).
114
Valores temporales
SP
Variables locales
FP
Dinamic Link (1)

Static link (2)
Direccion de retorno
Parametros
SP=Stack Pointer
FP=Frame Pointer
Valor de retorno (func)
Figura 6.3: Formato de un registro de a tiva in.
ha e apuntar al tope del sta k. Esta dire in ser usada omo dire in base
dentro del registro de a tiva in.
Los valores de las variables lo ales se a eden on desplazamientos negativos y

los parmetros on desplazamientos positivos (si el sta k re e ha ia dire iones
de re ientes).
Cabe a larar que todos los a esos a variables o parmetros se ha en usando el
modo de dire ionamiento basado, el ual es provisto por la mayora de las CPUs
modernas.
5. Si el lenguaje usa al an e estti o (stati s ope ), apila el stati link, el ual apunta
al registro de a tiva in ms prximo del bloque que lo ontiene estti amente
en el programa. Cabe a larar que si el lenguaje no es estru turado a bloques
( omo en el aso de C, el ual tiene slo dos ambientes, el lo al y el global), este
puntero no es ne esario pues el ambiente no lo al o es global o orresponde al
ambiente del invo ante, el ual puede a ederse mediante el frame pointer.
En la siguiente se in se analizar en detalle el manejo del al an e estti o.

6. La subrutina reserva lugar en el sta k para los valores de las variables lo ales. Esto
se realiza simplemente modi ando el valor del sta k pointer (de rementndolo
o in rementndolo, dependiendo ha ia adnde re e el sta k, si ha ia dire iones
re ientes o de re ientes).
El espa io requerido para las variables lo ales generalmente es determinado estti amente (tiempo de ompila in).
115
7. Se ontina on la eje u in del resto de las instru iones del uerpo de la rutina.
Los valores temporarios produ idos por la evalua in de expresiones omplejas
pueden apilarse en el tope del sta k.
8. Comienzo de las a iones de retorno de la subrutina: se eliminan las variables
lo ales. Nuevamente esto se realiza simplemente moviendo el tope del sta k (sta k
pointer).
9. Se desapila y re upera el frame pointer del registro de a tiva in anterior (invo ante).
10. Se eje uta el retorno (ej: instru in RET ), la ual desapila el ontenido del tope
del sta k y se lo asigna al program ounter.
11. El ontrol vuelve al invo ante, el ual debe eliminar los valores de los parmetros
a tuales (modi ando el tope del sta k). En el aso que se haya invo ado a una
fun in, se desapilar el valor retornado.
12. El invo ante ontina on su eje u in.
Es importante notar que ada subrutina tiene que realizar iertas a iones en la
entrada (a iones 1 a 6) y durante la salida o retorno (a iones 8 a 10). Estas a iones
se implementan on dos o tres instru iones de mquina y se denominan prembulo y
eplogo, respe tivamente.
Algunas arquite turas (ej: Intel IA32[7) proveen instru iones de mquina para
realizar estas opera iones .
6.2.1. Implementa in del manejo de al an e de ambientes.

Un lenguaje on al an e dinmi o (dinami binding ), el a eso a una variable o
es lo al al bloque orriente, o puede a ederse siguiendo el dynami link ya que la
bsqueda debe seguir la adena de invo a iones.
Los lenguajes on al an e estti o, requieren de un link adi ional ya que el a eso a una variable no lo al deber seguir la adena de de lara iones de los ambientes
estti os. Este link se ono e omo el stati link y se alma ena en el mismo registro
de a tiva in y apunta al registro de a tiva in orrespondiente a la a tiva in mas
prximo del bloque que lo ontiene estti amente en el programa.
El link estti o implementa en forma e iente la unin de ambientes , ya que representa el onjunto de ambientes de un bloque omo una lista enlazada.
El a eso a una variable no lo al deber seguir la adena estti a hasta a eder al
primer registro de a tiva in que orresponda al bloque que de lar tal variable.
En los lenguajes estru turados a bloques, omo Pas al y Oz, un a eso a una entidad no lo al requiere que se reali en
4 Instru iones ENTER y LEAVE en [7

5 Re ordar la semnti a de la senten ia lo al
116
pasos siguiendo el stati link, donde
de nuestro lenguaje kernel.
es la
diferen ia de niveles entre el bloque orriente y el bloque mas inmediato que de lar
la entidad. El osto es lineal.
Para evitar que los programas re orran parte de una lista en ada a eso a entidades
no lo ales, generalmente se utiliza un display.
El display es un arreglo el ual ontiene un puntero a la dire in base de un registro
de a tiva in por ada mbito (nivel) estti o del programa.
M
niveles
estaticos
nivel corriente = 2
Display
static links
Stack
Programa
Figura 6.4: Implementa in de stati s ope on un display.
La gura 6.4 muestra el uso de un display para un programa estru turado a bloques
on al an e estti o. La gura muestra que el programa se en uentra eje utando el
bloque
R,
el ual fue invo ado por
Q.
Se debe notar que, en este ejemplo, la adena dinmi a (invo a iones) no se orresponde on la adena estti a. El display permite el a eso a entidades no lo ales on
osto onstante, ya que se a ede a la dire in base del registro de a tiva in orrespondiente, mediante un desplazamiento dentro del display.
Este desplazamiento puede omputarse estti amente, es de ir, en tiempo de ompila in.
El display se a tualiza en la entrada de ada subrutina, salvando en el registro de

a tiva in la dire in del tope del display para luego ha er que el display apunte (en
el nivel orrespondiente) al tope del sta k (registro de a tiva in orriente).
En el aso que la subrutina orresponda a un nivel mayor que el orriente, se in rementa el nivel orriente el el display (se realiza un push sobre el display). Si la
subrutina invo ada se orresponde al mismo nivel estti o que el invo ante, el valor
del tope del display se reemplaza por el nuevo (se mantiene la altura del display).
Durante el retorno, se a tualiza el nivel orriente del display. Si el nivel del bloque
al que se retorna es igual al orriente ( omo en el aso del retorno de
R a Q, en la gura
6.4) se restaura el puntero del nivel orriente del display on el salvado en el registro
de a tiva in de la rutina que est retornando.
Los dems asos se dejan omo ejer i ios al le tor.
117
6.3. Valores reados dinmi amente. Manejo del heap.

La gran mayora de los lenguajes modernos permiten la rea in de valores dinmi amente, es de ir en tiempo de eje u in y que no estn aso iados a un mbito lo al
en parti ular.
Esos valores generalmente son referen iados por referen ias, omo por ejemplo en
Java o Eiel, o se pueden a eder mediante punteros, omo en Pas al, C o C++.
A modo de ejemplo, el siguiente programa Pas al muestra el uso de variables dinmi as:
...
Var p,q:^integer;
begin
new(p);
p^ := 100;
q := p;
...
end
...
dispose(q);
En el ejemplo, un valor numri o es reado (allo ated ) en el heap mediante el pro edimiento nativo
new, el ual toma su argumento (un puntero) por resultado, ha iendo

se apli a a un puntero y retorna
que apunte al bloque reservado. El operdor postjo

q
q
...
q
...
q
...
100
...
100
100
...
...
heap
stack
a) new(p)
stack
heap
heap
stack
c) q := p
b) p^ = 100
heap
stack
d) dispose(q)
Figura 6.5: Crea in y manejo de valores dinmi os.

el valor apuntado. El pro edimiento nativo
delete destruye (deallo ate ) el valor apun-
tado por su argumento. La gura 6.5 muestra los estados en la memoria.

Pas al y C son lenguajes en los uales el programador es responsable del manejo
del heap. Tanto la rea in omo la destru in de valores son expl itas.
Esto puede a arrear dos problemas en los programas:
Basura : se produ e uando un valor en el heap no puede ser referen iado porque
no hay forma de referen iarlos (las referen ias o punteros a l ya no existen).
Por ejemplo, si el ejemplo anterior se omitiera la senten ia
dispose(q), luego de
que se hubiesen destruido los punteros p y q sera imposible de referen iar al
118
bloque de memoria en heap y por lo tanto nun a podra ser reutilizado.
Este tipo de errores es bastante dif il de dete tar porque el programa puede
tener el omportamiento esperado, pero a medida que avan e su eje u in ir
onsumiendo el heap hasta que en algn momento la opera in de allo ation
falle.
Se di e que un programa que genera basura tiene memory leaks (lagunas de
memoria).
Referen ias olgadas : se produ e uando se intenta a eder a un valor que ha

sido destruido (deallo ated ).
Por ejemplo, si en el ejemplo anterior, luego de eje utar
senten ia
write p;
dispose(q), hubiese la
se produ ira una referen ia olgada. Otro error omn es
referen iar punteros o referen ias no ini ializadas.
Cuando un programa tiene referen ias olgadas, su omportamiento ser errti o
y a menudo se produ e el error segmentation fault (falla de segmenta in) .
6.3.1. Manejo del heap

El manejo del heap est implementado en las opera iones de allo ation y deallo-
ation de bloques en el heap. El manejador del heap ontiene dos listas, una que
memoriza los bloques asignados y otra que registra los libres. La gura 6.6 muestra
una representa in del heap.
Free list
Allocated list
HEAP
Figura 6.6: Estru turas de datos del heap.
6 El error es generado por el sistema operativo ya que el pro eso est tratando de a eder a un
segmento (bloque) de memoria sin permiso.
119
Hay lenguajes que permiten que los bloques del heap tengan tamao uniforme,
omo por ejemplo en Lisp y Haskell. Esto permite que el manejo del heap sea muy
simple.
El heap se divide en n bloques y en realidad no importa qu bloque se asigne en
un requerimiento pues son todos iguales.
Otros lenguajes, donde los valores pueden tener representa iones de diferentes tamaos ( omo es el aso de registros o arreglos), el heap tendr que ser manejado omo
una estru tura heterognea, es de ir puede tener bloques de diferentes tamaos. Esto
a arrea una ompli a in extra en el manejo, ya que ada bloque deber tener al
menos un des riptor de su tamao (adems de su dire in).
En este esquema, ini ialmente el heap tiene un ni o gran bloque disponible.
El manejo del heap on bloques de diferentes tamaos a arrea el problema de la
fragmenta in del heap. Esto quiere de ir que a medida que se van realizando requerimientos y libera in de bloques de diferentes tamaos en el heap, van quedando hue os
entre los bloques en uso que podran ser menor que el tamao de un prximo bloque
requerido, por lo que este ltimo requerimiento no podra ser satisfe ho.
Existen dos posibles solu iones a este problema:
1.
Compa ta in total: este pro eso movera los bloques en el heap para re onvertir los mltiples bloques libres en uno solo. El problema de la ompa ta in
total es que hay que modi ar las referen ias ya que los bloques fueron movidos.
2.
Compa ta in par ial:
esto se realiza en la opera in de libera in de un
bloque. Al momento de liberar un bloque, si ste tiene bloques adya entes libres,
se fusionan en un solo bloque. Esto es mas e iente y generalmente en la pr ti a
fun iona muy bien.
6.3.2. Manejo automti o del heap

Los lenguajes de programa in modernos proveen me anismos para el manejo de la
memoria en forma automti a. Por ejemplo los lenguajes fun ionales de la familia ML
y Haskell proveen tanto la rea in de valores omo su destru in de manera impl ita.
Algunos lenguajes, omo por mu hos lenguajes orientados a objetos y a lases, tienen
operadores para la rea in de objetos pero no para su destru in. La destru in es
impl ita.
El manejo de la memoria en forma automti a evita que los programas ontengan
los errores men ionados anteriormente on algn osto en la performan e de la eje u in de los programas.
Hay bsi amente dos mtodos manejo de la memoria que se han implementado en
los lenguajes de programa in modernos.
1.
Contadores de referen ias: ada bloque de memoria que representa un valor

del programa tiene aso iado un ontador de referen ias al bloque.
120
En ada opia de referen ias, esto es en las opera iones de asigna in y pasaje
de parmetros, los ontadores orrespondientes se a tualizan.
A modo de ejemplo, en una asigna in de la forma
p := q
(donde
son
punteros o referen ias a bloque del heap), se deber de rementar el ontador de

referen ias delo bloque previamente referen iado por
p,
para luego in rementar
el ontador de referen ias del bloque referen iado (o apuntado) por
q.
Cada vez que una referen ia naliza su tiempo de vida (porque naliza la eje u in del ambiente en que fue de larado), el ontador de referen ias se de rementa.
Si el ontador lleg a ero, signi a que el bloque ya no puede ser referen iado,
por lo tanto puede liberarse en forma segura.
Se debe notar que en el lenguaje kernel utilizado aqu en in remento del ontador
se debera implementar en la opera in primitiva Bind. Se deja omo ejer i io la
redeni in de la semnti a de la mquina abstra ta para el uso de ontadores
de referen ias.
Este me anismo es simple de implementar pero tiene la desventaja de tener una

sobre arga (overhead) onstante en la eje u in de un programa. Cabe re ordar
que las prin ipales opera iones de omputa in el el binding.
2.
Re ole tores de basura:
en este enfoque el me anismo permite que el pro-
grama vaya generando basura y en algn momento de la eje u in
7 se dispare
un pro eso, el re ole tor de basura al ual se en argar de dete tar los bloques
basura para luego re uperarlos.
6.3.3. Algoritmos de re ole in de basura

Existen mu hos algoritmos de re ole in de basura. Esta ha sido y sigue sindolo
en la a tualidad un rea de a tiva investiga in y hay libros de texto ompletos ni amente destinados a ubrir esta rea.
Se des ribirn tres algoritmos, los uales son la base de la gran mayora de los
dems.
Mark and sweep:
la idea se basa en un algoritmo de dos etapas. La primera
de ellas (mark) se en arga de mar ar los bloques o upados, es de ir los bloques

al anzables desde las referen ias (o punteros) del programa. Este algoritmo generalmente omienza explorando la memoria estti a y el sta k, para luego realizar
una lausura de los bloques al anzados dire tamente . Este algoritmo deber tener en uenta que di ha rela in de al anzabilidad puede ser li a.
7 Por ejemplo uando no se pueda satisfa er un

8 Un bloque podra ontener referen ias a otros
requerimiento de allo ation en el heap.

bloques
121
El segundo paso (sweep) se en arga de tomar los bloques no mar ados y adi ionarlos a la lista de bloques libres. Obviamente los bloques no mar ados son
inal anzables desde las referen ias del programa, por lo que son basura.
Genera ionales:
la idea onsiste en dividir al heap en genera iones. El ma-
nejador va ategorizando los bloques en genera iones en base a la dura in de

su tiempo de vida a tiva. Los bloques de mayor tiempo de vida se alma enan
en su propia parti in (genera in). El re ole tor pro esa las genera iones mas
jvenes primero. Cada ierto tiempo el re ole tor mueve bloques a genera iones
mas viejas. Esto permite que se haga una re ole in par ial (o in remental) de
la basura lo que permite que el tiempo de eje u in del re ole tor no sea larga y
el programa no sufra largas pausas.
Copia:
los re ole tores de basura basadas en opia generalmente parti ionan
el heap en dos partes. Una parte es la regin a tiva. Cuando una soli itud no
puede ser satisfe ha, el re ole tor opia todos los bloques al anzables de la regin
a tiva a la otra, la ual pasa a ser la nueva regin a tiva. Durante el pro eso de
opia se puede ha er la ompa ta in de los bloques. La regin anterior queda
ompletamente disponible para la prxima opia.
Esta t ni a tiene la ventaja que realiza una sola pasada pero omo desventaja,
aprove ha la mitad del heap.
Un problema adi ional a resolver on el manejo automti o de la memoria es el
uso de programas externos. Por ejemplo, un programa podra tener una estru tura de
datos que puede ser a edida de una bibliote a externa al lenguaje. En este es enario,
si la estru tura fuese re lamada por el manejador de la memoria, sera un error. Otro
ejemplo sera que un programa tenga referen ias a datos externos. Esos datos no podran ser re lamados uando ya no estn en uso ya que el lenguaje no puede manejar
el heap del programa (o bibliote a) externa.
Estos asos generalmente se solu ionan de dos maneras posibles. Las bloques de
memoria lo al referen iados externamente se mar an y no se re laman. Los datos externos referen iados por el programa tienen aso iados proxies, los uales realizan el
re lamo al programa externo uando el proxi en s sea re lamado. Esta opera in generalmente se ono e omo naliza in.
Mu hos lenguajes de programa in brindan me anismos para la naliza in. Es
el aso de los destru tores de C++ (los uales son invo ados automti amente en la
destru in de un objeto, ya sea automti amente uando ste reside en el sta k o
por la opera in
delete)
y el mtodo nalize() de Java, el ual es invo ado por el
re ole tor de basura.
122
Captulo 7
Programa in orientada a
objetos
En este aptulo se des ribirn los prin ipales on eptos de la programa in orientada a objetos (OOP). Se estudiarn on eptos tales omo objetos, lases, heren ia,
dynami binding, polimorsmo y genere idad.
Se extender el lenguaje kernel para soportar los on eptos men ionados y se dar
su semnti a formal en la mquina abstra ta.
7.1. Objetos
Una fun in (o varias) on una memoria interna (estado) se denomina un objeto.
Se ver que los objetos son muy tiles. A modo de ejemplo, la gura 7.1 muestra la
implementa in de un objeto Counter.
lo al C in
C={NewCell 0}
fun {In }
C := C + 1
C
end
fun {Read}
C
end
end
Figura 7.1: Implementa in de un objeto Counter
La senten ia
lo al dene la variable C, la ual es visible slo dentro del bloque. El

In y Read.
ontador slo es a esible por medio de las fun iones
123
Programa in orientada a objetos
Esto se llama en apsulamiento, ya que la variable est o ulta al resto del programa
y slo puede ser manipulado por una interfa e, las fun iones
In y Read.
La separa in entre interfa e e implementa in es fundamental para realizar abstra iones de datos. Esto permite que los programas se abstraigan de la implementa in
de los objetos y slo tengan que respetar su interfa e. Este me anismo es es en ial para
una ade uada modulariza in en la programa in en gran es ala.
7.2. Clases
En la se in anterior se ha denido un objeto. Cmo es posible rear ms objetos
omo
Counter?
Para ello es ne esario una fbri a (fa tory ) de objetos. Las lases en la OOP juegan
el papel de fbri as de objetos. Una lase tambin dene un mdulo: una implementa-
in de un tipo abstra to de datos que dene una interfa e y o ulta su implementa in

(y su estado).
La gura 7.2 muestra una posible implementa in de una lase que rea objetos
Counter. La fun in NewCounter retorna un registro on

Read que operan sobre la variable C, la ual permane e o ulta.
de tipo
las fun iones
In
de lare fun {NewCounter}

lo al C In Read in
C={NewCell 0}
fun {In }
C := C + 1
C
end
fun {Read}
C
end
ounter(in :In read:Read)
end
end
Figura 7.2: Una posible implementa in de una lase.
Un programa podr usar la fun in
NewCounter
para rear diferentes instan ias
(objetos):
C1 = NewCounter
C2 = NewCounter
{Browse C1.In }
{Browse C2.Read}
Se extender el lenguaje n leo on estado para dar soporte sint ti o a la programa in orientada a objetos, omo se muestra en la gura 7.3.
124
<statement> ::=
|
< lass-des > ::=
<method>
::=
<expr>
::=
|
|
<attr_init> ::=
<meth_head> ::=
<arg>
lass <variable> { < lass-des > } { <method> }

...
from { <expr> }+ | prop { <expr> }+ | attr { <attr_init> }+
meth <meth_head> [ '=' <var> ( <in_expr> | <in_stmt> ) end
lass '$' { < lass_des > } { <method> }
self
...
( [! <var> | <atom> | unit | true | false ) [ ':' <expr>
( [! <var> | <atom> | unit | true | false ) [ ':' <expr>
[ '(' { <arg> } ['...' ')' [ '=' <var>
::= [ <feature> ':' ( <var> | '_' | '$' ) [ '<=' <expr>
Figura 7.3: Sintaxis extendida para soportar OOP.
Las extensiones al lenguaje n leo ser una abstra in lingusti a ya que se ver
omo se puede representar una lase y sus ara tersti as espe as.
La gura 7.4 muestra un ejemplo de la lase
Counter on la sintaxis extendida.
lass Counter
attr val;
meth init(Value)
val := Value
end
meth in (Value)
val := val + Value
end
meth get
val
end
end
Figura 7.4: Ejemplo de una lase.
La gura 7.5 muestra una posible implementa in de la lase

guaje n leo on estado.
Como se puede apre iar en la gura 7.5, la lase
Counter
Counter
en el len-
se representa omo un
registro on dos ampos: una lista de atributos y otro registro uyos ampos se ligan a
referen ias de los pro edimientos orrespondientes. Este ltimo registra los mtodos.
New. A ontinua in
Counter y su utiliza in.
Los objetos (instan ias de lases) se rean mediante el operador

se muestra la rea in de un objeto (instan ia) de la lase
C = {New Counter init(0)}

{C in (6)}
{Browse {C get}}
125
lo al
pro {Init M S}
init(Value)=M in (S.val) := Value
end
pro {In M S}
in (Value)=M in (S.val) := (S.val) + Value
end
pro {Get M S}
get = M in (S.val)
end
in
Counter = (attrs:[val methods:m(init:Init in :In get:Get))
end
Figura 7.5: Ejemplo de una lase.
Una senten ia de la forma

del mtodo
in (x),
{C in (x)} se denomina una apli a in sobre el objeto
invo a in de un mtodo. El objeto sobre el ual se realiza la
apli a in se denomina el objeto destino (target). En otros lenguajes populares orientados a objetos omo C++, Java, Eiel, et , es omn la nota in
obje t.method.
Es importante notar que en esta forma de representar lases y objetos, una apli a in se implementa por medio de un me anismo de mensajes odi ados en forma
de registros. La de odi a in del mensaje se logra por medio de pattern mat hing en
ada pro edimiento.
Para poder entender la semnti a ompleta de este ejemplo, a ontinua in se
muestra la deni in del operador
New.
fun {New Class Init}

Fs = {Map Class.attrs fun {$ X} X#{NewCell _} end}
S = {List.toRe ord state Fs}
pro {Obj M}
{Class.methods.{Label M} M S}
end
in
{Obj Init}
Obj
end
Esta fun in rea el estado del objeto y lo ini ializa ( reando para ada uno de
ellos una nueva elda). Adems dene un pro edimiento
Obj
on un argumento. Este
pro edimiento representa el objeto y su argumento el mtodo (mensaje) a ser invo ado. Cuando se invo a
Obj
on un mensaje omo argumento, redirige (invo a) al
pro edimiento orrespondiente al mensaje pasndoles omo parmetros el registro que

odi a el mensaje y el estado del objeto.
126
Es posible ver al pro edimiento (objeto)
Obj
omo un despa hador (dispat her)
de mensajes, esto es, rela iona un mensaje on un pro edimiento que implementa el
mtodo orrespondiente. El mtodo destino es el rtulo del registro que odi a el
mensaje.
New
Se debe notar que la fun in
Init).
antes de retornar el objeto, invo a al mtodo de
in ializa in (
Esta implementa in de objetos es un ejemplo de programa in on estado y alto

orden (la fun in
New retorna un
pro edimiento).
El estado del objeto est o ulto por las reglas de al an e lexi ogr o.
7.3. Clases y objetos

Una lase dene los omponentes que tendrn los objetos (instan ias) orrespondientes a la lase. En el lenguaje denido en este aptulo existen tres tipos de partes
que un objeto puede tener:
Atributos: denidos por la palabra attr. Un atributo es una elda que alma ena
parte del estado del objeto.
En la terminologa de la OOP, un atributo se ono e generalmente omo una
variable de instan ia o ampo (eld member en C++).
Cada instan ia (objeto) tiene su propio onjunto de atributos, aunque algunos

lenguajes proveen me animos para que todas las instan ias de una lase ompartan algunos de sus atributos, omo por ejemplo on el modi ador
stati
de
Java o C++.
Los atributos podrn ser a edidos y modi ados por los mtodos de la lase.
Algunos lenguajes permiten que se a edan a los atributos desde otros objetos,
si es que son visibles. Algunos lenguajes, omo Eiel, ven a los atributos omo
fun iones de onsulta (query), por lo que los atributos pueden ser slo ledos
desde otros objetos, si la visibilidad lo permite.
Mtodos: de larados por
la palabra
meth. Un
mtodo representa un pro edi-
miento o fun in que en una invo a in se eje uta en el ontexto de un objeto

en parti ular, el ual es el objeto target.
Propiedades: de larados on la palabra prop. Una propiedad modi a el omportamiento de los objetos. Una propiedad puede rear un errojo (lo k) en
ada objeto reado, til en on urren ia. La propiedad
final afe ta a
la heren-
ia (prohbe su extensibilidad). La heren ia se ver mas adelante en este aptulo.
Otros lenguajes de POO tienen algunos de estos me anismos omo modi adores
de la de lara in de ada lase, mtodo o atributo.
127
7.3.1. Ini ializa in de atributos

Los atributos se pueden ini ializar de dos formas posibles:
por instan ia : un atributo puede tener un valor ini ial en ada instan ia, lo que
requiere que debern ser ini ializados on valores pasados omo parmetros del
mtodo de ini ializa in.
por lase : un atributo podr tener el misno valor ini ial para todas las instan ias
de la lase. En su de lara in se debe dar su valor in i ial, luego del smbolo
(dos puntos).
Por ejemplo: attr ity : Ro Cuarto
En la mayora de los lenguajes OO, la ini ializa in de objetos se realiza por medio
de mtodos u opera iones espe iales denominados onstru tores.
7.3.2. Mtodos y mensajes

Los mtodos de una lase son invo ados por medio de mensajes odi ados omo
registros. El en abezado de ada mensaje es un patrn que en aja on un re ord.
Como onse uen ia de este me anismo, una apli a in (invo a in) de la forma
M}
{Obj
puede ha erse de dos formas posibles:
M es un re ord estti o : es de ir, es ono ido en tiempo de ompila in, omo

por ejemplo:
{Counter in (6)}
M es un re ord dinmi o : es posible una expresin
{Obj M}
donde
es una
variable. Esto da una gran exibilidad, ya que los registros pueden ser reados
dinmi amente, es posible rear mensajes de la misma forma.
Tambin es posible denir mtodos on un nmero jo o variable de argumentos.
Un mtodo on un nmero variable de argumentos (usando el smbolo
...) es a eptado
si on uerdan los argumentos listados expl itamente.

El en abezado de un mtodo puede ligarse a una variable. Por ejemplo, la de lara in
meth foo(a:A b:B ...) = M

% body
end
En este aso la variable
M referen ia al mensaje ompleto al momento de una invo-
a in.
Un argumento puede ser usado op ionalmente en una invo a in, ya que es posible
denir un valor por omisin (default)por ada argumento en el en abezado de un
mtodo, tal omo lo muestra el siguiente ejemplo.
128
meth foo(a:A b:B<=5)

% body
end
Un mtodo puede ser privado (o ulto fuera de la lase) si se utiliza una variable
protegida por las reglas lexi ogr as (dentro de la lase).
Tambin es posible que el nombre (label) de un mtodo pueda denirse o omputarse dinmi amente, utilizando el operador
pre ediendo a la variable usada omo
rtulo del mtodo. Por ejemplo:
meth !A(x)
% body
end
Esto es posible ya que las lases se onstruyen dinmi amente.
Finalmente, es posible denir el mtodo
otherwise, el ual fun iona
omo un m-
todo por defe to en el aso que el mensaje falle en el mat hing on los dems. Si este
mtodo existe en una lase, sus instan ias a eptarn ualquier mensaje.
El ompilador de Oz, trata de optimizar las invo a iones. En el aso de que el mensaje sea estti o, rea un llamado tan rpido omo una invo a in a un pro edimiento,
sino ompila a una llamada general sobre el objeto. Esta ltima instru in usa una
t ni a llamada memoriza in o at hing. La primera invo a in es lenta, pero las
siguientes se realizan muy rpido porque el mtodo ya se en uentra en la a h.
7.3.3. Atributos de primera lase

Los nombres de los atributos de un objeto pueden determinarse dinmi amente.
Por ejemmplo, la lase
lass Inspe tor

meth get(A ?X)
X = A
end
meth set(A X)
A = X
end
end
Cualquier lase que tenga mtodos de ese tipo dejar sus atributos expuestos al
mundo exterior. Esto es peligroso omo t ni a de programa in pero puede ser muy
til para ha er introspe in (a eder a informa in sobre un objeto dinmi amente) y
depura in (debugging).
129
7.4. Heren ia
Las lases son una unidad de modulariza in y tabin denen nuevos tipos de datos.
Esta dualidad es fundamental para denir abstra iones de datos en forma in remental.
La heren ia es un me anismo para denir nuevas lases a partir de otras existentes.
Una lase
puede heredarse desde una lase base
ti amente ontiene (hereda) las deni iones de
A.
A,
lo que signi a que
autom-
Adems en la deni in de
B,
es
posible in luir nuevas ara tersti as (atributos, mtodos y propiedades) y redenir
A.
B es la sub lase
ara tersti as heredadas de

Se di e que la lase
de
A y esta ltima es su super lase
(inmediata).
La rela in de heren ia es transitiva y no reexiva. La heren ia dene una rela in

entre lases que puede modelarse omo un rbol.
Una lase puede heredar de una o ms lases, lo ual se ono e omo heren ia ml-
tiple. Las lases de las uales se hereda, apare en en la lusula
from en la deni in
de una lase.
En presen ia de heren ia mltiple la rela in de heren ia entre lases puede modelarse omo un grafo dirigido a li o.
Deni in 7.4.1
Un mtodo en una lase
sobrees ribe (overrides) ualquier m-
todo on el mismo rtulo denido en sus super lases.

El on epto de sobrees ritura (o sobre arga) es mas general que la redeni in, la
ual es una sobrees ritura respetando el perl del mtodo (tipo de valores de retorno
y nmero y tipos de los argumentos).
7.4.1. Control de a eso a mtodos (ligadura estti a y dinmi a)

La sobrees ritura (o sobre arga) de mtodos en lases heredadas ompli a la desi in de a qu mtodo invo ar ya que puede haber varios andidatos. El siguiente
ejemplo muestra tal situa in.
lass A {
...
meth m
{self m1 ...}
end
meth m1
...
end
...
end
lass B from A
...
meth m1
...
{A,m ...}
end
...
end
130
O = {New B ...}, la ual rea una instan ia de

{O m}, lo ual invo a al mtodo m. En el uerpo de m
se invo a al mtodo m1, l ual fue sobrees rito en la lase B. Esta situa in presenta
una pregunta: a qu versin de m1 se debe invo ar en el uerpo de m?
Claramente, la respuesta es que, en este aso, debera invo ar a la versin de m1 de
la lase B.
Dada una senten ia de la forma
tipo
B,
y la siguiente apli a in
Esto trae un problema de ompila in. Al ompilarse la lase
el ompilador no
puede asumir a qu mtodo invo ar espe amente ya que puede ser sobrees rito en
alguna sub lase, por lo que deber generar digo para que la determina in del mtodo a invo ar se reali e dinmi amente (en tiempo de eje u in). Esto se ono e omo
ligadura dinmi a (dynami binding) o ligadura tarda (late binding).
m1
Ahora supongamos que en el mtodo

de la lase
A.
m1
de la lase
Si se realiza la invo a in de la forma
B se desea invo ar al mtodo

{m1 ...}, sera interpretada
por el ompilador o intrprete omo una llamada re ursiva. Para realizar la invo a in
deseada, se deber indi ar expl itamente al mtodo
denota omo
{A,m1 ...}.
m1
de la lase
A.
En Oz esto se
Esta ltima forma de invo a in se puede determinar estti amente, ya que expl itamente se denota a qu mtodo espe o se desea invo ar. En esta forma de
invo a in se utiliza ligadura estti a (stati binding).
En Java se utiliza la palabra reservada
super
para espe i ar que el destino es
un mtodo espe o de la super lase. En C++, la sintaxis es similar a Oz, ya que

existe un operador de al an e de la forma
lase ::member , similar al operador de Oz ,.
En otros lenguajes de programa in, una invo a in puede omitir el objeto destino
(target), en uyo aso se interpreta omo que el objeto destino de la invo a in es
self. El operador self se ono e en

Current omo en Eiel.
otros lenguajes omo
this (en
C++, Java, et ),
La determina in en tiempo de eje u in del mtodo al ual se debe invo ar a arrea

desafos de e ien ia de su implementa in.
Para lograr una mayor e ien ia en el me anismo de invo a iones (dispat hing)
mu hos lenguajes orientados a objetos, prin ipalmente aquellos on sistemas de tipos estti os, omo C++, Java o Eiel, implementan las invo a iones omo llamadas
a pro edimientos (y no omo mensajes), los uales tienen un argumento adi ional
self ),
que generalmente tiene la forma de puntero o referen ia al estado del objeto
target. Todas las invo a iones on destino impl ito se realizan sobre el parmetro
self.
En los omienzos de 1980, Bjarne Stroustrup , propone una implementa in de lo

que l llam mtodos virtuales, es de ir aquellos mtodos uyas invo a iones deben
1 Creador
e implementador original de C++.

131
determinarse en tiempo de eje u in, on omplejidad temporal onstante.

El mtodo onsiste en que ada lase tiene aso iada un ve tor de punteros a sus
mtodos que requieran binding dinmi o. Adems ada objeto debera ontener un
ampo adi ional: un puntero a di ha tabla. Cada invo a in dinmi a se resuelve
on un a eso extra a la tabla de punteros. El ompilador omputa estti amente el
desplazamiento (oset) onstante para ada mtodo dentro de la tabla.
o1
vt
m1_A(...)
VT_A
...
m2_A(...)
o2
vt
m2_B(...)
VT_C2
o3
vt
...
...
Figura 7.6: Ejemplo de uso de tablas virtuales
o2
La gura 7.6 muestra un es enario de esta implementa in, donde los objetos
son instan ias de una lase
redenido el mtodo
m2.
o3
es una instan ia de una lase
B en
o1 y
la ual se ha
Este mtodo es uno de los ms usados en lenguajes que soportan objetos y heren ia,
omo Java, C#, Eiel y otros.
Uno de los prin ipales problemas on esta implementa in es el tamao de las tablas, ya que en sistemas grandes, on ientos de lases, el tamao de las tablas puede
al anzar tamaos onsiderables en memoria. En presen ia de heren ia mltiple, el tamao es un problema an mayor.
Mu hos lenguajes permiten ontrolar al programador ontrolar el tamao de las

tablas. C++ deja en manos del programador la de isin sobre qu mtodos tendrn
binding dinmi o y ules no. Por omisin los mtodos de C++ utilizan binding estti o (la semnti a no deseada en OOP). Un mtodo denido
virtual utilizar binding
dinmi o en sus invo a iones.
En otros lenguajes, por el ontrario, su semnti a por omisin es binding dinmi o

( omo Java y Eiel). Estos lenguajes permiten expli itar que sobre algunos mtodos
no ser ne esario apli ar binding dinmi o usando las palabras reservadas
Java) o
frozen (en
Eiel).
132
final
(en
7.5. Control de a eso a elementos de una lase

La gran mayora de los lenguajes que soportan objetos, proveen me animos para
ontrolar el a eso a los omponentes de una lase. Cada miembro de una lase se
dene dentro un al an e espe o.
Generalmente ada miembro tiene un al an e por omisin y se puede alterar por
medio de iertas palabras reservadas, omo por ejemplo,
publi , prote ted y private
el ual dene su visibilidad al resto del programa.

Un miembro
publi es visible para el resto del programa. Un miembro private es

prote ted es visible dentro
visible slo dentro de la lase (o instan ia). Un miembro

de la lase y de sus lases derivadas.
Oz no tiene palabras reservadas para modi ar su visibildad. Un mtodo puede

ha erse privado usando omo rtulo una variable (ya que el ompilador rea un identi ador para la variable) o usando una variable pre edida del operador ! (es ape), lo
que signi a que la variable se ha denido fuera de la lase.
Eiel tiene un me anismo muy general, ya que permite agrupar los miembros (features) de una lase indi ando su visibilidad espe i ando la lista de lases (tipos) que
pueden a eder a esos miembros.
La espe i a in de una lase en una lusula
feature permite
que ualquier ins-
tan ia de esa lase o de sus lases derivadas, puede a eder al miembro.

En Eiel, al igual que en Java, todas las lases derivan (por omisin) de una lase
raz. En Eiel, esa lase raz se denomina
Obje t.
ANY,
mientras que en Java se denomina
C++ no tiene esa semnti a, por lo ual permite al programador disear su propia
jerarqua de lases partiendo desde su propia lase raz.
7.6. Clases: mdulos, estru turas, tipos?

Como ya dijo anteriormente, una lase dene un mdulo y un tipo. Esta dualidad
en la visin de una lase a menudo onfunde a los programadores po o experimentados
al momento de disear jerarquas de lases ya que es posible disear jerarquas on
una visin estru tural en lugar de tener una visin on respe to a una jerarqua de
tipos de datos.
Es omn en ontrar en ierta bibliografa introdu toria en OOP, ejemplos tales
omo que una lase
Cir ulo hereda
de una lase
Punto.
Desde un punto de vista es-
tru tural puede tener sentido, ya que es razonable pensar que un r ulo ontiene un
punto (su entro). Desde el punto de vista de tipos de datos, justamente lo inverso es
razonable: es posible pensar que un punto es un r ulo de radio ero.
El ejemplo anterior muestra la di ultad de disear orre tamente jeraquas de
lases. La visin mas ade uada es la visin de tipos, ya que la heren ia es una rela in
133
es-un, es de ir que una instan ia de una lase derivada, tambin es ompatible (es del
tipo) de su super lase. El tipo de datos de una lase in luye los subtipos orrespodientes a sus sub lases, por lo que la super lase es un tipo mas general, mientras que sus
sub lases denen subtipos.
La visin de lases omo tipos satisfa e la propiedad de sustitu in, es de ir que ada opera in que a ta sobre objetos de un tipo dado, tambin a ta sobre instan ias
de sus subtipos (sub lases). Mu hos lenguajes de POO, omo C++, Java, Smalltalk,
et , estn diseados para esta visin.
El lenguaje Eiel, est diseado para soportar ambas visiones.
7.7. Polimorsmo
Es posible denir la heren ia en trminos de un sistema de tipos en base a una
rela in tipo-subtipo. Esto permite implementar abstra iones polimr as - pro edimientos, fun iones y estru turas de datos ( ontenedores) - ya que una abstra in que
se basa en una lase
A,
a epta instan ias de
Ao
de sus lases derivadas.
El polimorsmo basado en heren ia requiere que las opera iones tomen referen ias o punteros a objetos, en lugar de obje tos por opia. Esto permite implementar
A toma el
A o alguno de sus derivados. Este
f ilmente el on epto que una referen ia o puntero a un objeto de tipo

signi ado que es una referen ia a on objeto de tipo
tipo de polimorsmo se ono e omo polimorsmo por in lusin, ya que se basa en la

rela in tipo-subtipo. Para poder implementar este me anismo, es ne esario que las
invo a iones a mtodos tengan binding dinmi o.
7.8. Clases y mtodos abstra tos

Las lases y la heren ia permiten la onstru in en forma in remental de jerarquas
de lases que representarn una jeraqua de tipos de datos.
Esta onstru in in remental permite denir mtodos generales que onfan en
otros mtodos que podrn (o debern) ser sobre argados (espe ializados) en sub lases.
Es fre uente que algunos mtodos en una lase no puedan ser denidos, ya que su
implementa in depender de ada sub lase en parti ular.
Deni in 7.8.1
Un mtodo es abstra to si no tiene una implementa in.
Deni in 7.8.2
Una lase es abstra ta si no permite tener instan ias de ella. Esto
es lo mismo que de ir que tiene una implementa in par ial.

Es f il de ver que si una lase ontiene al menos un mtodo abstra to, no podr
tener instan ias, ya que esos objetos tendran una implementa in par ial, por lo que
la lase deber ser abstra ta.
134
Las lases abstra tas permiten denir moldes de las sub lases y delega en ellas la
responsabilidad de ompletar su implementa in.
Uno de los prin ipales objetivos de las t ni as de programa in orientada a objetos
es la reutiliza in de digo, lo ual se logra maximizando las abstra iones (an la
pro edural).
Una lase abstra ta puede tener implementados mu hos de sus mtodos, los uales
sern reutilizados en las subl ases.
A ontinua in se muestra el uso de lases abstra tas.
abstra t lass Persistent {

...
abstra t state get_state();
save() { medium.save(get_state()); }
...
storage medium;
...
};
lass Person extends Persistent {
...
state get_state() { return id+name+address; }
...
};
La lase abstra ta
Persistent dene el mtodo save el ual invo a a get_state(),

Persistent deber imple-
el ual es abstra to. Cualquier lase on reta derivada de

mentar
get_state().
7.9. Delega in y redire in

La heren ia no es el ni o me anismo para denir abstra iones en forma in remental. La heren ia requiere de espe i a iones ade uadas de jerarquas de lases, lo
que no siempre es f il. Adems requiere de binding dinmi a.
Es posible lograr efe tos similares on la heren ia utilizando mtodos mas simples
omo lo son la redire in (forwarding) y la delega in. Estos me anismos se denen a
o1 no omprende un mensaje m, ste se reenva, en forma

o2.
nivel de objetos: si un objeto

transparente, a un objeto
La diferen ia entre redire in y delega in es la forma mo tratan a

En redire in,
self
en
o2 se
self.
o1 y o2 mantienen sus entidades separadas. Una invo a in sobre

o2.
realiza sobre
La redire in puede ser implementada en Oz por medio del mtodo
135
otherwise.
En delega in,
o1 y o2 existe referen ian a una misma entidad, por ejemplo, o1.

self en o2 se har sobre o1.
Una invo a in sobre
La delega in permite denir jerarquas a nivel de objetos, no lases. En lugar de

ha er una jerarqua de lases, se denen objetos que delegan en otros (en tiempo
de rea in de los objetos).
o1 y o2, suponiendo que tienen un mtodo setDelagate, tal

{o2 setDelegate(o1)} ha e que el objeto o2 delega sus invo a iones a o1.
otras palabras, o1 se omporta omo una super lase de o2.
Dados dos objetos,

que
En
Una propiedad importante de la delega in es que
self
se preserva, por lo que
los mtodos a tan sobre el estado del objeto que ha ini iado la delega in.
7.10. Reexin
Un sistema (u objeto) es ree tivo si ste puede inspe ionar parte de su estado
de eje u in dinmi amente. La reexin puede ser puramente instrospe tiva, es de ir slo podr leer su estado interno, o intrusiva, es de ir que puede modi ar su estado.
La ree in puede ha erse a bajo o alto nivel. En el primer aso, podra ser que es
posible ver los elementos de la pila semnti a omo lausuras (ambientes). Un ejemplo
del segundo aso podra ser que es posible ver la memoria omo un ve tor de enteros.
Algunos lenguajes modernos permiten instrope in, omo en Java y Eiel. Otros
lenguajes mas dinmi os ofre en reexin intrusiva, ya que es posible agregar, modi ar y eliminar omponentes de objetos dinmi amente, omo por ejemplo en Python
y Ruby.
Otros lenguajes omo C++, permiten una reexin muy limitada. Slo permite
inspe ionar el tipo de un objeto si se utiliza RTTI (Run Time Type Information ).
7.11. Meta objetos y meta lases

La OOP es un rea muy apropiada para apli ar reexin a diferentes niveles. Por
ejemplo, el sistema podra examinar (y posiblemente ambiar) la jerarqua de lases
dinmi amente (por ejemplo en Smalltalk y Ruby), o ambiar la semnti a de algunos
me anismos bsi os, omo por ejemplo la heren ia ( mo se realiza la determina in
de qu mtodo invo ar) y mo se realizan las invo a iones.
La des rip in de mo se omporta un sistema de objetos en su nivel bsi o se
ono e omo un meta-proto olo.
La posibilidad de modi ar el meta-proto olo brinda un gran poder des riptivo
que puede tener apli a iones muy interesantes, omo depura in (debugging), personaliza in ( ustomizing) y separa in de on eptos ( omo por ejemplo, en riptar los
136
mensajes de las invo a iones, introdu ir me anismos de toleran ias a fallas o introdu ir
aspe tos .
Las meta lases, en lenguajes omo Smalltalk, Ruby o CLOS (Common Lisp Obje t
System) dan una gran exibilidad para implementar sistemas que son muy exibles en
tiempo de eje u in ya que permiten pr ti amente la onstru in y modi a in de
objetos y de sus jerarquas en tiempo de eje u in.
Los lenguajes que no disponen de meta lases, se denominan orientados a lases (y
tal vez no ne esariamente a objetos). Lenguajes omo C++, Java O Eiel, no proveen
meta lases, aunque las ara tersti as y me anismos provistos por meta lases pueden
ser provistos por mtodos de lases espe as ( omo
o algunos mtodos de la lase
Obje t de
INTERNALS
MEMORY
de Eiel)
Java.
El proye to Open C++ [8 tiene omo objetivo proveer de me anismos de meta lases
para C++ por medio de un pre- ompilador de meta lases (que genera lases C++).
7.12. Constru tores y destru tores

En la terminologa de la OOP, se ono e omo onstru tor a un mtodo que se
invo ar automti amente por el sistema en el momento de la rea in de un objeto
(tal omo la opera in
New
des ripta anteriormente).
En la mayora de los lenguajes orientados a objetos es posible denir varios onstru tores. Alguno de ellos se invo ar (expl itamente o impl itamente) durante la
rea in de un objeto.
En algunos lenguajes, omo C++ y Java, los onstru tores deben tener el mismo
nombre de la lase y no retornan ningn valor (ni siquiera
void).
En ese aso, un
onstru tor es sobre argado.

Es omn en la pr ti a de la programa in que uando un objeto est por destruirse, se desee realizar algunas opera iones antes de su destru in, tal omo liberar
re ursos ( errar ar hivos, onexiones, et ).
En C++ esto se logra por medio de los destru tores. Un destru tor es un mtodo
que tiene el mismo nombre que la lase sin parmetros (y sin valor de retorno). Es
invo ado automti amente por el sistema inmediatamente antes que el objeto sea
delete).
virtual ya que puede ser invo ado en
destruido (automti amente por la reglas de al an e o por una opera in

Un destru tor en C++ puede denirse omo
un ontexto polimr o donde se requiere determinar el destru tor (mtodo) orrespondiente en forma dinmi a.
Los lenguajes que proveen amnejo automti o de la memoria, omo Eiel o Java,
permiten que las lases redenan un mtodo provisto en la lase base del lenguaje. Por
2 La programa in orientada a aspe tos permite modi ar el sistema de eje u in para introdu ir
omputa iones en puntos espe os de un programa dado sin modi arlo, es de ir ha erlo por fuera.
137
ejemplo, la lase base
Obje t de Java provee un mtodo finalize() el ual se invo a
uando el re ole tor de basura re lama el objeto.
7.13. Heren ia mltiple

La heren ia mltiple a arrea algunos problemas adi ionales a la heren ia simple.
Cuando una lase
C hereda
de ms de una lase, es posible que o urran los siguientes
in onvenientes:
1. oni tos de nombres de miembros de lases : en el aso que las super lases tengan
algn miembro on nombre omn.
2. problema del rombo : si dos (o ms) lases, sean
omn ( ) y una lase ( ) hereda de

dos aminos diferentes de la lase
A.
C,
heredan de una lase
se da el problema que
hereda por
Figura 7.7: Problema del rombo on heren ia mltiple
Esto trae dos problemas: el primero es un ovbio oni to de nombres y el segundo

es la repeti in de atributos. La gura 7.7 muestra tal situa in.
Cualquier lenguaje de programa in que soporte heren ia mltiple deber ofre er
me anismos para resolver estos problemas. En el aso de C++, el problema de nombres
no existe ya que es posible referen iar a un miembro espe o de una lase utilizando
el operador de al an e (smbolo ::).
El problema de la repeti in de atributos se resuelve en C++ deniendo en una
de las ramas de la heren ia (en el ejemplo, podra ser en la lase
la super lase ( ) en forma virtual. Se usa la palabra reservada

muestra a ontinua in.
138
B)
que se hereda de
virtual,
tal omo se
lass
lass
lass
lass
A
B
C
D
{...};
: virtual publi A {...};
: publi A {...};
: publi B, publi C {...};
Eiel soporta mltiples lusulas de heren ia y en ada una se pueden renombrar

e indenir features (attributos o mtodos). Por ejemplo:
lass A
feature {ANY}
attr:T
m(x:INTEGER)
...
end
lass B
inherith A
...
end
...
end
lass C
inherith A
rename m as m_of_A
end
...
end
lass C
inherith B
indefine attr1
end
inherith C
end
end
7.14. El lenguaje Java (parte se uen ial)

Java es un lenguaje orientado a objetos derivado de C++. Java se a er a mu ho
a un lenguaje orientado a objetos puro ( asi todas las osas son objetos, ex epto las
senten ias y los tipos de datos primitivos).
Los objetivos de Java y C++ son diferentes. Mientras que C++ permite la representa in dire ta de los datos en hardware y una tradu in de sus senten ias simple
y dire ta a lenguaje de mquina, Java da una representa in abstra ta de los datos y
realiza manejo de la memoria en forma automti a.
Java soporta on urren ia nativa (threads) en un modelo de memoria ompartida
(shared memory) y omputa in distribuida sobre mltiples plataformas. Tiene un
139
sistema de objetos pre-elaborado.

Para lograr los objetivos men ionados, un sistema Java tiene dos omponentes:
el ompilador (java ):
que tradu e las deni iones de lases en los programas
.java) a ar hivos objetos en formato Java

. lass).
fuentes (ar hivos on subjo

(ar hivos on subjo
byte ode
la mquina virtual (java virtual ma hine o jvm ): que se en arga de argar, enlazar y eje utar lases. La mquina virtual es un intrprete del lenguaje assembly
virtual java byte ode. Cada plataforma on soporte para Java debe implementar
su propia jvm.
Java es un lenguaje estti amente tipado (al igual que C++), on lases, objetos
pasivos y threads. A diferen ia de C++, los valores en java pueden ser enteros, reales
en punto otante, ara teres (uni ode), lgi os (booleans) y referen ias a objetos.
No es posible de larar objetos dire tamente, sino referen ias a objetos, lo que ha e
que el me anismo de pasaje de mensajes sea por valor (las referen ias se pasan por
valor).
Una variable de larada tiene un valor ini ial predenido para ada tipo de dato (a
diferen ia de C++).
Soporta asigna in simple de atributos utilizando la palabra
final, lo ual es equi-
valente a los objetos onstantes de C++. La misma palabra puede utilizarse para
expresar que un mtodo no puede sobre argarse en lases derivadas .

El on epto
self
se denomina
this,
el ual es una referen ia al objeto a tivo del
thread orriente.
Las lases pueden ontener atributos (llamados elds en la terminologa Java) y
mtodos.
Cada deni in de atributos o mtodos puede tener propiedades (las uales pre eden a la de lara in) de las siguientes ategoras:
visibilidad:
omo
publi , prote ted
private
on el signi ado que se vio
on anterioridad.
modi abilidad: on final omo se expli mas arriba.

tiempo de vida: on la palabra stati , la que onvierte el elemento (atributo
o mtodo) en elemento de lase y no de objetos. En el aso de atributos, esto
permite denir ampos ompartidos (shared) entre todos los objetos. Cuando se
apli a a un mtodo, es posible invo arlo sin rear una instan ia de su lase. Un
ejemplo de su apli a in es la fun in
main, la ual ha e de fun in de arranque
de un programa Java y es invo ada por la jvm.

Cualquier lase puede ontener una fun in
main. Esto
quiere de ir que un pro-
grama Java podra tener mu hos puntos de ini io, dependiendo de la lase por
la ual se de ini io al programa.
3 Esto
pone algn lmite en las tablas de despa ho.

140
.
Una diferen ia on C++, es que este permite al programador sobre argar asi la
totalidad de los operadores del lenguaje .
lass Int {
private int value;
publi Int(int value) { this.value = value; }
publi int get_value() { return value; }
publi set_value(int v) { value = v; }
publi set_value(Int other) { value = other.get_value(); }
}
lass Example {
publi void sqrt(Int n)
{
n.set_value( n.get_value() * n.get_value(); )
}
publi stati void main(String[ args)

{
int x = 5;
Int v = new Int(x+10);
Example.sqrt(v);
System.out.println("v=" + v.get_value());
}
Figura 7.8: Ejemplo de un programa Java.
La gura 7.8 muestra un ejemplo de un programa Java.
7.14.1. Heren ia
Java soporta heren ia simple, aunque es posible simular la heren ia mltiple usando
interfa es.
La heren ia se expresa por la palabra
extends (equivalente
al
from).
Una interfa e es una des rip in de un proto olo. Contiene de lara iones de mtodos (no atributos) sin denir (sin uerpo).
Las interfa es se pueden heredar (in lusin textual) y una lase puede implementar
una interfa e.
Esto ltimo se reeja en la de lara in de una lase utilizando la palabra
4 Salvo
los operadores ::, -> y ..

141
implements.
No se deben onfundir a las interfa es on lases abstra tas. Una lase abstra ta generalmente tiene una implementa in par ial (de sus mtodos) y puede tener
atributos. Una interfa e no tiene estado.
A diferen ia de C++, la semnti a del sistema de objetos es ligadura dinmi a (la
ade uada), por lo que no ha e falta de larar a qu mtodos se les puede apli ar un
tipo de ligadura.
En el aptulo 8 se mostrarn ejemplos de heren ia ya que analizarn los me anismos de soporte a la on urren ia en Java.
7.15. Genere idad

Se ono e omo genere idad a los me anismos para denir algoritmos y tipos de
datos en forma abstra ta, en el sentido que pueden operar sobre ualquier tipo de
datos. El (nombre) de los tipos de datos de las abstra iones son parmetros de la
deni in.
Se diferen ian on deni iones polimr as al estilo del polimorsmo paramtri o
en que las deni iones genri as son esqueletos de fun iones y tipos de datos, a partir
de los uales el omilador generar versiones espe as en base a los tipos de datos
on que se instan ien.
Este me anismo de polimorsmo tambin se ono e omo polimorsmo por instan-
ia in.
Tambin se ono e a la genere idad omo polimorsmo estti o ontrastando on
el polimorsmo basado en heren ia, tambin llamado polimorsmo dinmi o.
Mas all de sus diferen ias, lo interesante es que ambos me anismos se pueden
ombinar, lo que da omo resultado un polimorsmo mas general.
Si bien la genera idad no es ex lusiva a la OOP, se des ribe aqu ya que varios
lenguajes de programa in de este paradigma lo soportan, omo por ejemplo, C++,
Java, Eiel y otros.
A modo de ejemplo, a ontinua in se muestra el uso de la lase
ARRAY
de la
bibliote a estndar de Eiel:
lass A
...
ve 1:ARRAY[INTEGER
ve 2:ARRAY[STRING
...
end
lass ARRAY [T
...
rep:NATIVE_ARRAY[T
...
end
En C++ las deni iones genri as se denominan templates. Estos lenguajes proveen en su bibliote a estndar un onjunto de deni iones genri as tanto omo algoritmos (fun iones) omo lases, las uales generalmente representan estru turas de
datos omnmente usadas omo pilas, listas, onjuntos, et . Estas estru turas de datos
142
en la jerga de la OOP se ono en omo ontenedores ( ontainers).

A ontinua in se des ribe el me anismo de templates de C++.
7.15.1. Templates (plantillas) de C++

El me anismo de plantillas de C++ puede apli arse tanto a fun iones omo a lases
y estru turas. La sintaxis de una plantilla sigue el siguiente esquema:
template <generi -args><definition>

donde <definition> puede ser una deni in
de una fun in, lase o estru tura.
En la deni in se pueden men ionar los argumentos de la plantilla.

Los argumentos de una plantilla se debe separar por oma. Un argumento genri o
tiene la forma
typename T donde T es
en parmetro formal de la plantilla.
template <typename T>

T add(T onst & v1, T onst & v2)
{
return v1 + v2;
}
template <typename T1, typename T2>

stru t pair {
T1 first;
T2 se ond;
};
Figura 7.9: Ejemplos de plantillas (templates) en C++.
La gura 7.9 muestra un ejemplos de una plantillas.

Se rea una instan ia on reta (de una fun in o lase) uando en una de lara in
o en una expresin se ha e referen ia parmetros de tipo on tipos on retos. Por
ejemplo, la expresin
add(5,x)
int add(int onst &v1, int onst &v2) ...,

x es de tipo entero. La expresin
add(s,string("...")
rea una instan ia de add para el tipo string, la ual retornar la on atena in de
sus argumentos, ya que el operador + est denido omo la on atena in en la lase
string.
rea una instan ia de la fun in
asumiendo que
La de lara in
pair<string,int>address;
genera una instan ia de la lase (o estru tura)
se ond de tipo int.
pair
on
first
de tipo
string
C++ provee en su bibliote a estndar un onjunto de plantillas, tanto de fun iones

omo estru turas de datos (abstra t ontainers ). Este onjunto de plantillas se ono e
omo la
STL (Standard Template Library).
143
Mu has de las fun iones denen algoritmos abstra tos, omo
find, et .
Entre los ontenedores abstra tos se en uentran
sort, a umulate,
ve tor, list, sta k, map, set
otros.
Estos ontenedores utilizan iteradores (iterators) para el a eso a los elementos que
ontienen.
Un iterador es una abstra in de un puntero, estn denidos omo lases genri as y denen al menos operadores omo
operator==(), operator++() y operator*()
(igualdad, in remento y referen ia in, respe tivamente).

Otras lases abstra tas denen obje tos-fun in, objetos que representan fun iones,
lo que puede ha erse en C++ on aquellos objetos uyas lases tienen sobre argado el
operador de invo a in a fun in (operador
())
#in lude <iostream>

#in lude <string>
#in lude <algorithm>
using namespa e std;
lass ase_less
{
publi :
bool operator()(string onst &left, string onst &right) onst
{
return str ase mp(left. _str(), right. _str()) < 0;
}
};
void print(string s)
{
out << s << endl;
}
int main(int arg , har *[argv)
{
ve tor<string> v(argv,argv + arg );
sort(v.begin(), v.end(), ase_less());
for_ea h(v.begin(), v.end(), print)
}
Figura 7.10: Ejemplos de uso de la STL.
La gura 7.10 muestra un ejemplo de uso de la STL.
144
Java ofre e abstra t ontainers al estilo de Eiel, on una sintaxis similar al de

C++ aunque no tan poderoso en su expresividad.
Los templates de C++ denen una espe ie de meta-lenguaje en ual puede ser
utilizado para instruir al ompilador de mo generar (y an evaluar) digo C++.
Con este me anismo es posible realizar evalua in en tiempo de ompila in, lo que
permite implementar una espe ie de evalua in par ial estti amente.
7.16. Ejer i ios

1. Dada la siguiente lase en Oz, mostrar su tradu in en el lenguaje kernel on
estado.
lass Counter
attr val
meth init(V)
val := V
end
meth in (V)
val := val + V
end
end
2. El siguiente digo muestra la rea in y uso de un objeto de tipo Counter.
C={New Counter init(0)}

{C in (6)}
...
Denir el pro edimiento
New,
el ual toma una lase y un mtodo ini ial (deno-
minados onstru tores en otros lenguajes de programa in orientados a objetos)

y retorna un objeto (instan ia) de la lase.
3. A menudo se di e que la invo a in a un mtodo sobre un objeto puede verse
omo un mensaje a l. El me anismo de manejo de objetos usado hasta aqui (en
Oz), Cmo se representan los mensajes?
4. Mostrar on un ejemplo que en Java utiliza dynami dispat hing y C++ utiliza
stati dispat hing por default.

5. Determinar si el destino (target) de la siguiente expresin puede ser determinada
estti amente o no:
145
...
super.m();
...
Justi ar la respuesta.
6. Implementar en Java, C++, Eiel y Ruby el TAD lista (heterognea). Denir
una lase abstra ta y al menos dos implementa iones: sobre arreglos y nodos
enlazados.
Mostrar ejemplos de uso.
7. Modi ar la lase lista de C++ para alma enar valores de un tipo T on reto
(no de sus derivados).
8. Expli ar omo se puede resolver el problema del rombo ( on heren ia mltiple)
en C++ y Eiel.
9. Dar un ejemplo de mo se puede implementar un diseo on heren ia mltiple
en Java.
10. En lenguajes omo C++ o Java, podemos hablar de mensajes o son en realidad
invo a iones a pro edimientos? Justi ar la respuesta.
11. Des riba las ventajas y desventajas de manejar las invo a iones a mtodos omo
mensajes versus invo a iones a pro edimientos.
12. Es ribir un programa en C++ que ordene los argumentos que pueda re ibir
desde la lnea de omandos durante su invo a in. Deber usar los algoritmos
de la STL (Standard Template Library)
sort y alguno de los objetos-fun iones

()) de ompara in (greater-equal,
(objetos que tienen sobre argado el operador

less, et ).
13. Es ribir un programa que sume y multiplique los elementos de un ve tor. Los
elementos debern estar alma enados en un objeto de tipo
utilizar el algoritmo genri o
a umulate.
14. Es ribir en C++ una lase parametrizada
bintree<T>,
ve tor<int>. Deber
la ual ontenga las
opera iones habituales de manejo de rboles binarios y que dena el iterador
preorder-iterator,
el ual debe permitir realizar un re orrido preorden del
rbol.
Un iterador es una abstra in de un puntero y debe mnimamente denir los
siguientes operadores:
operator==(): operador de
operator++():
ompara in (igualdad).
operador de post-in remento.
referen ia in de un elemento del ontenedor.
146
operator*():
operador de
15. Es ribir una lase parametrizada
ref_ ount_ptr
que represente punteros on
ontadores de referen ias. Cuando el ltimo puntero a un objeto dado est por
destruirse, ste deber destruir al objeto apuntado.
147
Captulo 8
Con urren ia
En este aptulo se abordan on eptos sobre eje u in on urrente de varias unidades de eje u in.
Algunos programas, se pueden es ribir ms f ilmente omo un onjunto de a tividades que eje utan independientemente. Tales programas se denominan on urrentes.
Programas que intera tan on el ambiente omo agentes (o servi ios), interfa es
gr as de usuario (GUIs), sistemas operativos, et , se es riben naturalmente omo
un sistema on urrente.
Cada una de esas a tividades eje utndose en forma on urrente puede intera tuar, en algn punto del programa, on otras. Por ejemplo, pueden ompartir iertos
re ursos (variables, ar hivos, et ) y en mu hos asos es ne esario un me anismo de
sin roniza in para el a eso a los mismos.
Los programas se es riben siguiendo alguna lgi a de omportamiento de sus partes, omo por ejemplo, siguiendo diseos liente-servidor o produ tor- onsumidor.
Los modelos de eje u in on urrentes pueden lasi arse en dos esquemas:
1. memoria ompartida (shared memory) : ada a tividad o mdulo on urrente del
sistema a ede a un rea de memoria omn. El me anismo natural de omuni a in entre las a tividades es el uso de variables ompartidas. En este modelo,
ada a tividad se denomina omnmente un hilo (thread) de eje u in.
2. pasaje de mensajes (message passing) : las a tividades tienen su propia rea de
memoria y se omuni an por medio de mensajes, los uales se envan por anales
de omuni a in ( hannels). En este modelo, es omn que las a tividades se

denominen pro esos o tareas (tasks). Este modelo es omnmente utilizado en
sistemas distribuidos dbilmente a oplados omo las redes. Las reglas que denen
formatos de los mensajes y las polti as de intera in entre los pro esos, denen
un proto olo de omuni a in.
Como se ver mas adelante, ambos modelos son equivalentes en poder expresivo,
ya que ada uno de ellos puede denirse en trminos del otro.
148
Con urren ia
8.1. Con urren ia de larativa

En sta se in se extender el lenguaje n leo del modelo de larativo on on urren ia y perman er de larativo, es de ir que se mantienen los mtodos de razonamiento del modelo de larativo.
El me anismo onfa en el on epto de variables data-ow (ujo de datos) las uales
pueden ser ligadas a un ni o valor. Esto arroja dos resultados importantes:
Los resultados del programa sern los mismos, independientemente si se utiliza
on urren ia o no.
Lo nuevo es que un programa puede ser omputado en forma in remental, a
medida que arriban los datos de entrada. Por ejemplo, un thread puede leer
datos de la entrada y otro thread pro esar esos datos. Es un ejemplo de lo que
se ono e omo un stream. Esto impli a que un programa puede no terminar, ya
que si se dejan de ingresar datos los threads quedarn suspendidos hasta que se
ingresen nuevos datos.
El lenguaje ser extendido in luyendo
una nueva senten ia:
thread <s> end. Un thread es una senten ia de eje u in
en una nueva pila (sta k) de la mquina. La mquina se extiende para tener

varias pilas semnti as en lugar de una omo en el modelo se uen ial.
in luir un nuevo orden de eje u in: por medio de disparadores (triggers) y una
nueva instru in primitiva
{ByNeed P X},
la ual permitir realizar ompu-
ta iones bajo demanda, omo eje u in perezosa (lazy).
8.1.1. Semnti a de los threads

En la mquina extendida se mantiene la memoria de asigna in ni a
bientes los formatos de una pila semnti a
los am-
(< s >, E).
Ahora la mquina soportar mltiples pilas semnti as, por lo que un estado de
eje u in ser un par
(M ST, ),
donde
M ST
es un multiset ( onjunto on elementos
on o urren ias mltiples). Es ne esario un multiset porque es posible tener, en un

momento dado, mltiples pilas semnti as on el mismo ontenido.
Una omputa in sigue siendo una se uen ia de estados de eje u in.
El estado ini ial de la mquina sigue onteniendo la senten ia prin ipal del programa, es de ir es un estado de la forma
([< s >, ], )
(el multiset tiene un ni o sta k,
on la memoria va a y es sta k tiene el estado de eje u in formado por la senten ia

prin ipal del programa on un ambiente va o).
La mquina, en ada i lo de eje u in, sele iona una pila semnti a y eje uta la
senten ia del tope tal omo lo ha a en el modelo se uen ial .
1 La
ni a a in adi ional es la sele in de la pila semnti a al ini io del i lo.

149
Con urren ia
Esta sele in la realiza una fun in interna de la mquina denominado plani a-
dor (s heduler).
La mquina termina su eje u in si todas las pilas semnti as estn en estado -
nalizadas (terminated).
La semnti a de la senten ia thread se dene omo
({[thread
<s>end,E]
donde el operador
+ ST }
M ST , ) ({[(<s>,E)]}
es la unin de multisets y el operador
ST
M ST , )
es la on atena in
de elementos del sta k.
La eje u in de una senten ia thread rea un estado donde el uerpo del thread se
eje uta en el ontexto de una nueva pila semnti a.
El administrador de la memoria requiere ser extendido:
Una pila semnti a terminada (terminated) puede ser eliminada.
Una pila semnti a bloqueada puede re lamarse si es que su ondi in de a tiva in depende de una variable inal anzable. Es f il de ver que una pila semnti a
en estas ondi iones nun a podr pasar al estado a tivo (runnable).
En este modelo toman importan ia las senten ias bloqueantes o suspendibles. En el
modelo se uen ial, una senten ia al bloquearse tiene omo efe to la suspen in de la
eje u in de la mquina, ya que dispona de una ni a pila semnti a.
En el modelo on urrente, una pila semnti a puede pasar a estado suspendido
(por ejemplo en una senten ia
if
la variable de ondi in puede no estar ligada), pero
en el futuro la mquina podr eje utar otra senten ia (de otra pila semnti a) que
ligue tal variable, lo que har que la pila anterior pase al estado runnable nuevamente.
Este es un me anismo de sin roniza in entre threads y se ono e omo variables
data ow o data driven ya que se basa en el ontrol de ujo de datos de las variables.
8.1.2. Orden de eje u in

Dado un programa, en el modelo on urrente podemos obtener diferentes se uen ias
de estados de eje u in (dependiendo del thread elejido en ada paso de eje u in).
Cada se uen ia se denomina una traza de eje u in. Estamos asumiendo que nuestra mquina bsi amente sigue operando en forma se uen ial, pero desde el punto de
vista del programador o usuario, es posible ver que los diferentes threads evolu ionan
simultneamente.
La idea de simultaneidad depende de la visin del pasaje del tiempo. En una mquina omo la que se ha denido, la idea de simultaneidad est dada por la eje u in
150
Con urren ia
de senten ias de diferentes threads de eje u in en ada paso. Estas opera iones realizadas a gran velo idad, tal omo lo pueden ha er las omputadoras a tuales, pueden
dar la ilusin de eje u in simultnea de los diferentes threads.
Esta forma de eje u in se uen ial de senten ias de diferentes threads en ada i lo,
se denomina inter ala in (interleaving).
Un sistema de omputa in on varias mquinas, operando simultneamente, permitir eje u in realmente simultnea o en paralelo, por lo que estos sistemas se denominan sistemas paralelos.
En ambos sistemas de omputa in (ni a o mltiples mquinas), el orden de las
omputa iones de los diferentes threads o programas est ontrolada por el sistema, no
por el programador o usuario, por lo que lleva a que la eje u in sea no determinsti a.
El no determinismo en el orden de eje u in de las senten ias, puede ha er que los
resultados de un programa sean diferentes en dos trazas de eje u in distintas. En el
modelo on urrente de larativo, sto no puede su eder, ya que las variables toman un
ni o valor (no pueden ser modi adas), por lo que se ono e omo determinismo no
observable.
Dado un programa on urrente, sus pasos de eje u in forman un orden ausal, el
ual es un orden par ial (a diferen ia de un programa se uen ial que forma un orden
total).
Deni in 8.1.1
si pre ede a otra

se debe eje utar antes que sj .
En un orden ausal una senten ia
pertene en al mismo thread y en l
I1
I2
si
T2
Ia
Ib
Ic
I1
Ia
Ib
I1
Ic
I2
Ia
I1
Ib
Ic
I2
sj
si ambas
I2
T1
Ia
Ib
Ic
a) Orden causal
...
b) Posibles ordenes (interleaving)
Figura 8.1: Orden ausal e inter ala in (interleaving)
La gura 8.1 muestra la rela in de un orden ausal de los threads
T1 y T2 y algunas
posibles se uen ias dadas por interleaving. La rela in de orden ausal del ejemplo,
puede des ribirse por extensin omo
Deni in 8.1.2
{(Ia , Ib ), (Ia , I1 ), (Ib , Ic ), (I1 , I2 )}.
Un onjunto de ligaduras en la memoria se denomina una
in ( onstraint).
151
restri -
Con urren ia
Deni in 8.1.3
Para ada variable
onjunto de todos los valores posibles de
Deni in 8.1.4
Dos restri iones
c1
y ada restri in
c, values(x, c)
c.
ontiene el
tal que se verique
c2
son
lgi amente equivalentes si
1. ontienen las mismas variables, y

2. para ada variable
x, values(x, c1 ) = values(x, c2 ).
En el modelo on urrente de larativo pueden o urrir dos osas para todas las eje u iones posibles de un programa:
1. puede no terminar, o
2. puede terminar par ialmente ( omputar valores par iales) y di hos valores son
lgi amente equivalentes.
Esto impli a que el no determinismo en el orden de las eje u iones de las senten ias del programa on urrente, no es visible, ya que siempre se obtienen resultados
equivalentes.
8.2. Plani a in de threads (s heduling)

Un plaini ador o menejador de threads debera ser justo (fair), en el sentido que
ada thread eventualmente deber progresar. Un s heduler en la pr ti a debe tener
otras ara tersti as deseables. Sheduling, a tualmente es un ampo muy a tivo de
investiga in.
Un s heduler debera ser parametrizado para poder implementar polti as de plani a in on prioridades, ontabilidad (tiempos de eje u in de ada thread) e implementar el ambio de threads ( ontext swit h) muy e ientemente.
Algunos sistemas permiten asignar prioridades a los threads, ya sea tanto estti a
omo dinmi amente.
A modo de ejemplo, mu hos sistemas intera tivos van priorizando los threads o
pro esos orientados a entrada-salida sobre los orientados a uso de pu intensivos, brindando as mejores tiempos de respuesta a las sesiones intera tivas.
Si bien en la mquina abstra ta denida en este do umento se estable e que en
ada i lo de eje u in se sele iona una de las pilas semnti as, en la pr ti a ha er
un ambio de ontexto por ada instru in hara que la sobre arga (overhead) del
s heduler sea mayor que el requerido para pro esar los threads en s.
Por esto, en general un s heduler sele iona otro thread (o pila semnti a) por dos
posibles motivos:
1. el thread orriente se suspende, ya sea por una senten ia suspendible o por una
opera in de entrada-salida la ual puede tomar un largo tiempo (o indenido)
o
152
Con urren ia
2. el thread ya ha tenido el ontrol por demasiado tiempo, por lo que es momento

de darle el ontrol a otro.
La segunda ausa estable e que el s heduler debe determinar un intervalo de tiempo mximo de eje u in para ada thread. Este intervalo se denomina time sli e o
quantum. El intervalo de tiempo puede determinarse estti amente o dinmi amente.

Mu hos s hedulers modernos al ulan el intervalo en forma dinmi a, generalmente es
una fun in que depende de varios parmetros omo velo idad de la CPU, prioridad
del thread, et .
8.3. Control de eje u in

Los threads se ono en omo un me anismo de on urren ia ooperativa. Los programas que utilizan threads se programan de tal forma donde ada thread aporta a
un n omn on los dems.
En un sistema operativo, en ambio, ada programa tiene un n individual, por lo

que los diferentes programas en eje u in ompiten por los re ursos del sistema. En
un sistema operativo, ada programa en eje u in se denomina pro eso o tarea (task).
Threads
(concurrencia cooperativa)
Procesos
(concurrencia competitiva)
Figura 8.2: Pro esos o tareas y threads
Para dar algn grado de ontrol sobre la eje u in de los threads en un programa,
generalmente los sistemas de threads ofre en algunas fun iones sobre threads. Oz ofre e
el mdulo
Thread que ontiene las opera iones sobre threads (entre otras) que se listan
en la tabla 8.3.
153
Con urren ia
Opera in
Des rip in
{Thread.this}
Retorna el nombre del thread orriente
{Thread.state T}
Retorna el estado del thread T
{Thread.suspend T}
Suspende al thread T
{Thread.resume T}
A tiva al thread T
{Thread.preempt T}
Interrumpe (quita el ontrol) al thread T
{Thread.terminate T}
Finaliza (inmediatamente) al thread T
{Thread.wait T}
Espera por la termina in del thread T
Figura 8.3: Algunas opera iones sobre threads.
8.3.1. Corrutinas
Una orrutina es un thread no interrumpible. Una orrutina abandona la pu en
forma voluntaria.
Las orrutinas tienen dos opera iones fundamentales:
Spawn P:
rea una nueva orrutina on
omo pro edimiento prin ipal de la
orrutina y retorna un identi ador de la orrutina reada.
Resume C: transere el ontrol a la orrutina C.

Cada orrutina tiene la responsabilidad de transferir el ontrol a las dems orrutinas que ooperan on un n omn.
Se puede apre iar que un sistema de orrutinas es simplemente un me anismo
expl ito de transferen ia de ontrol a diferentes unidades de eje u in.
8.3.2. Barreras
Una barrera (barrier) es una opera in de ontrol de eje u in on urrente que
permite estable er un punto de en uentro (punto de sin roniza in) de diferentes omponentes on urrentes (threads o pro esos). Una barrera permite estable er un punto
de eje u in que requiere que otros omponentes al an en antes de poder ontinuar.
Una barrera tambin se ono e omo rendezvous.
...
{Barrier [X1 X2 ... Xn}
Figura 8.4: Ejemplo de una barrera (rendezvous).
La gura 8.4 muestra un ejemplo de una barrera usando variables data-ow, donde
el pro edimiento
...Xn estn
Barrier suspende al thread orriente hasta que las variables X1, X2,
ligadas.
Las barreras generalmente denen puntos de sin ronoza in en base a requerimientos del omputa in del programa: dada una barrera, el thread no puede ontinuar
154
Con urren ia
hasta que los dems threads ( ooperativos) no hayan nalizado la omputa in de

iertos valores.
8.3.3. Eje u in perezosa (lazy)

En el ontexto de evalua in perezosa, una expresin se evala uando su resultado
es requerido en alguna parte del programa.
En esta se in se desarrolla una estrategia de ontrol de eje u in mas general,
llamada eje u in lazy,que la evalua in lazy, ya que sta ltima estrategia se apli a
a un ontexto de eje u in se uen ial.
El modelo de eje u in lazy extiende el modelo on urrente de larativo on un
nuevo on epto: disparadores por ne esidad (by need triggers).
Para poder dar soporte a los disparadores por ne esidad, se in luir una nueva
opera in primitiva a la mquina abstra ta on urrente:
{ByNeed P Y},
la ual tiene
thread P Y }, ex epto para s heduling, en el sentido
el mismo efe to que la senten ia {

que el pro edimiento
P ser eje utado (plani ado) solamente si el valor Y es ne esitado.
A ontinua in se des ribe la semnti a de la opera in
{ByNeed P Y}.
Se extiende la memoria para disponer de una memoria de triggers,

La semnti a de la senten ia
1. si
E(< y >)
no es determinado, rear el trigger
memoria de triggers
2. si
({ByN eed < x > < y >}, E)
es
trig(E(< x >), E(< y >))
a la
E(< y >) es determinado,

({< x > < y >}).
rear un nuevo thread on la senten ia ini ial (o
uerpo)
Un trigger se a tiva uando existe un valor

de
y,
trig(x, y)
y
es de ir, existe un thread que est suspendido por
En la a tiva in de un trigger
1. Eliminar
trig(x, y)
trig(x, y)
o se est ligando a
y.
se eje utan las siguientes a iones:
de la memoria de triggers
2. Crear un nuevo thread uya senten ia ini ial sea
y > y}).
y se dete ta una ne esidad
({< x > < y >}, {< x > x, <

x on el
O sea que produ e la invo a in al pro edimiento ligado a
argumento ligado a
y.
Esta extensin de la mquina requiere que se extienda el manejador de la memoria

(garbage olle tor):
Una variable
Si la variable
x
y
es al anzable si
trig(x, y)
se torna inal anzable y el
puede eliminar de la memoria
es al anzable.
trig(x, y) ,
el trigger
trig(x, y)
se
Es posible implementar eje u in perezosa (lazy) usando

es evaluada slo se requiere su resultado.
155
ByNeed. Una fun in lazy
Con urren ia
La abstra in lingsti a
trminos de
ByNeed.
fun lazy {F args} <s>end
dene a la fun in
en
Es bueno a larar que la evalua in lazy se diferen ia de la eje u in lazy presentada

aqu en el sentido que la primera se basa en un ambiente de eje u in se uen ial,
mientras que la ltima en un ambiente de eje u in on urrente.
Algunas apli a iones de la eje u in lazy son:
Lazy streams:
un stream es una lista de mensajes o valores, poten ialmente
innita, (una lista uya ola est dada por una variable no ligada). Las tuberas
(pipes) de los sistemas tipo Unix son un ejemplo de streams. Es omn en algunos lenguajes fun ionales que se denan listas por omprensin, las uales se
evaluarn en forma perezosa.
Operadores de alto orden: omo iteradores o ltros que apli an una fun in
a ada elemento de una lista, la ual se va onstruyendo bajo demanda.
Enlazado dinmi o (dynami linking):
utilizado omnmente para apli a-
iones basadas en el on epto de omponentes. El digo fuente de un programa

onsiste de un onjunto de espe i a iones (atributos, mtodos y propiedades)
denominados funtores. Una apli a in en eje u in onsiste de omponentes instan iados, denominados mdulos. Un mdulo se puede representar omo un registro que agrupa las opera iones del mdulo (en ada ampo). Los omponentes
se ligan bajo demanda, es de ir uando un mdulo se arga en memoria y se instan ia on un funtor. En el primer intento del programa de a eder a un ampo
(opera in) de un mdulo, se realiza el enla e.
8.4. Apli a iones de tiempo real

Un programa de tiempo real (real time) dene un onjunto de opera iones que
tienen que ompletarse antes de determinados instantes de tiempo (ven imientos).
Una apli a in se di e que es de tiempo real blando (soft real time) uando las opera iones debern ompletarse antes de los ven imientos orrespondientes en la mayora
de los asos.
Por el ontrarrio, una apli a in de tiempo real duro (hard real time), requiere que
siempre debern ompletarse las opera iones antes de los ven imientos orrespondientes.
Las apli a iones de tiempo real duro, omo por ejemplo, apli a iones de ontrol en
veh ulos, equipos mdi os, sistemas de omuni a iones, et , requiere soporte tanto de
hardware omo de software (sistema oeprativo).
Las apli a iones de tiempo real blando no tienen ven imientos estri tos y pueden
implementarse usando las siguientes opera iones (denidas en el mdulo
{Delay I}:
Time):
suspende la eje u in del thread que la eje uta por al menos
rosegundos.
156
mi-
Con urren ia
{Alarm I U}:
rea un nuevo thread que ligar
trans urido al menos
(a
unit
despus que hayan
mi rosegundos.
{Time.time}: retorna el nmero de segundos desde una fe ha dada (ej: el omienzo del ao orriente).
8.5. Con urren ia y ex ep iones

La on urren ia tiene que estar rela ionado al me anismo de ex ep iones. A modo
de ejemplo, supongamos que un thread eje uta la senten ia
X=2 (sobre la misma
variable
X).
X=1 y otro thread
eje uta
En este aso una de las dos opera iones de ligadura deber fallar (la que se eje ute
despus). Por esto el thread en el ual falle la opera in de bind deber disparar una ex ep in, dndole la opertunidad al thread de re uperarse, si es que atrapa la ex ep in.
Un problema adi ional surge on eje u in por ne esidad. Cul debera ser el
omportamiento de un disparo de un trigger y la omputa in de la fun in involu rada
falla?
Si la variable a ligar on el resultado de la fun in no se liga, el thread que demanda
el valor de la fun in no lograr su objetivo. Si la eje u in de la fun in aso iada al
trigger falla, a qu valor debera ligarse la variable a aso iar al resultado de la fun in?
Una solu in posible es ligar la variable a ligar on el retorno de la fun in a un
valor espe ial.
El valor espe ial podra ser
annotCal ulate.
Ese valor debera ser retornado
por alguna fun in primitiva de la mquina abstra ta. Esa fun in se denominar
FailedValue.
Ahora, on esta fun in es posible denir una fun in ms robusta de eje u in

por ne esidad, omo se muestra a ontinua in:
pro {ByNeed2 P X}
{ByNeed
pro {$ X}
try
Y in {P Y} X=Y
at h E then X={FailedValue E}
end
end
X
}
end
El pro edimiento
ByNeed2 se invo a de la misma manera que ByNeed, pero en apFailedValue.
sula la ex ep in en un valor
157
Con urren ia
8.6. Sin roniza in

Cuando un thread ne esita un valor al ulado por otro thread, el primer deber
esperar hasta que el resultado est disponible. Se di e que los threads se sin ronizan
segn la disponibilidad de resultados.
La sin roniza in es uno de los prin ipales on eptos de la programa in on urrente.
Deni in 8.6.1
1 , 2 . . . y 1 , 2 . . .,
i y j , si en ada traza de
j .
Sean dos threads T1 y T2, on senten ias
respe tivamente, un
punto de sin roniza in
eje u in posible (interleaving),
entre
se eje uta antes que
La sin roniza in puede ha erse de dos maneras:
dataow : ( on evalua in estri ta). Las opera iones que requieren un valor, debern esperar hasta que el valor est disponible.
bajo demanda : (eje u in peresoza). El intento de eje u in de una opera in,

ausa la evalua in de sus argumentos. El l ulo de los argumentos, ausa un
punto de sin roniza in entre las opera iones.
En un programa, la si roniza in puede ser
impl ita : los puntos de sin roniza in no son visibles en el texto del programa,
omo en el modelo de on urren ia de larativa des ripto hasta ahora.
expl ita : los puntos de sin roniza in son visibles en el programa y generalmente
toman la forma de opera iones que implementan errojos (lo ks) o monitores,
omo se des riben en la se in 8.7.
8.7. Con urren ia on estado ompartido

La on urren ia en el modelo on estado (variables mutables), rea problemas para
el desarrollo de programas. Si bien desde el punto de vista omputa ional este modelo
es equivalente al de on urren ia on pasaje de mensajes, ya que ste ltimo requiere
el on epto de estado para representar los puertos, el estilo de programa in es muy
diferente, por lo que es lgi o onsiderarlos modelos diferentes.
A modo de ejemplo, la gura 8.5 muestra un ejemplo en donde dos threads a tualizan una variable ompartida.
La salidas posibles del programa pueden ser: 0, 1 o 2. Se deja al le tor el ejer i io
de veri ar esta arma in.
Esto muestra que la salida depende del orden de eje u in (trazas) de las senten ias,
lo ual lleva a que se produz a no determinismo observable.
Su ede que ya no es posible lograr que dos restri iones sean lgi amente equivalentes para una variable
x.
158
Con urren ia
lo al X in
X := 0
thread X := X + 1 end
thread X := X * 2 end
{Browse X}
end
Figura 8.5: Ejemplo una ondi in de arrera.
El problema es que varios threads pueden estar a tualizando una misma variable y,
omo en el ejemplo mostrado, pueden o urrir ondi iones de arrera (ra e onditions).
La situa in mostrada en el programa ha e que no sea posible es ribir un invariante
on pre isin ya que en un punto de programa dado, el valor de una variable puede
ser in ierto.
lass Sta k
attr S
attr top
meth Push(V) S := V|S top := top + 1 end
meth Pop(?V) in lo al S1 in S = V|S1 S := S1 top := top - 1 end
end
Figura 8.6: Ejemplo una ondi in de arrera.
En el aso de la eje u in on urrente de opera iones sobre estru turas de datos,

omo por ejemplo opera iones sobre una pila, omo se muestra en la gura 8.6, el
invariante (ej:
pushes pops = top)
puede invalidarse en una traza de eje u in de-
terminada. Nuevamente, se deja al le tor el ejer i io, dar una se uen ia de eje u in
que invalide dado.
Para poder espe i ar invariantes mas pre isos en un programa, se requiere que se
introduz an puntos de sin roniza in, es de ir que se se uen ializen iertas opera iones
o que se garanti en que iertas se uen ias de senten ias, sobre iertos datos ompartidos, no puedan ser interrumpidas por el s heduler. Estos bloques de se uen ias que
deben eje utarse sin interrup in se ono en omo regiones rti as y se di e que deben eje utarse en forma atmi a ( on respe to a los dems threads que a eden a los
mismos re ursos o variables).
La programa in on urrente on estado ompartido onsiste prin ipalmente en el
re ono imiento y sin roniza in de las regiones rti as.
El re ono imiento de regiones rti as requiere que se indentiquen puntos del programa en el que podran o urrir ondi iones de arrera. Esta a tividad es realmente
dif il, omo se puede apre iar en las listas de errores reportandos en proye tos de
software omo sistemas operativos, servidores de bases de datos, et .
159
Con urren ia
8.7.1. Primitivas de sin roniza in

Este modelo requiere de opera iones que permitan sin ronizar los threads. Es posible lasi arlos en dos grandes grupos:
Cerrojos (lo ks):
permiten agrupar se uen ias de senten ias o instru iones
permitiendo que se eje uten en forma atmi a.
Semforos: un semforo, inventados por Dijkstra, es una variable (de tipo entera) espe ial protegida (ADT), el ual puede ser manipulada por tres opera iones:
init(s,n): ini ializa el semforo on el valor n.

P(s): intenta de rementar en uno el valor del semnforo,
si es que su valor
es positivo. En otro aso el thread invo ante deber esperar (bloquearse)

hasta que sea desbloqueado por otro thread.
V(s):
si hay algn pro eso bloqueado por el semforo, desbloquea uno y
retorna, sino, in rementa en uno el valor del semforo.
Las opera iones
se orresponden on los nombres originales en holands
que les dio Dijkstra, por Proberen (probar) y Verhogen (in rementar), respe tivamente.
Intuitivamente, un semforo representa el nmero de re ursos disponibles y por

lo tanto permite hasta
threads a eder a la regin rti a simultneamente.
Un semforo debe mantener el siguiente invariante:
V c(s) s P c(s) + initial_value(s)

donde
P c(s)
V c(s)
es la antidad de opera iones
es el nmero de opera iones
Monitores:
realizadas sobre el semforo
realizadas sobre
s.
los monitores utilizan lo ks y puntos de espera. Generalmente in-
wait)
luyen opera iones para esperar por una ierta ondi in (
signal).
y noti a in
de ondi iones (
Regiones rti as ondi ionales:
son abstra iones de uso de monitores en
forma de senten ias de un lenguaje. Un regin rti a est protegida on un lo k

asi iado a una ondi in. Un thread intentando ingresar a la regin ri a deber
esperar hasta que la ondi in sea verdadera.
Generalmente tienen la forma de
Transa iones:
region ... when < ond><s>end.
una transa in es una se uen ia de opera iones que pueden
ommit) o ser abortadas. En el aso que se produz a una

abort) el estado se retrotrae al estado previo del ini io de la
eje utarse on xito (

salida anormal (
transa in.
El lenguaje Oz ofre e las siguientes primitivas que implementan errojos reentran-
tes .
2 Un
lo k reentrante permite que se aniden lo ks por parte del mismo thread, sin bloquearlo.
160
Con urren ia
{NewLo k L}:
{IsLo k L}:
rea un nuevo lo k
retorna
L.
true si L refern ia un lo k.
lo k X then <s>end:
protege a la senten ia
utando una senten ia protegida por un lo k
<s> on el lo k X. Un thread ejeX impide que otro thread a eda
(debe esperar) al uerpo de la senten ia lo k sobre la misma variable.

La implementa in de primitivas de sin roniza in, omo lo ks y semforos, requiere de me anismos mas primitivos an para garantizar la atomi idad de sus implementa iones. Cabe ha er notar que una implementa in de las opera iones de lo k y unlo k o
P y V de semforos, tienen ondi iones de arrera sobre sus propias variables de estado.
En mu hos sistemas o lenguajes se implementan omo primitivas en donde la atomi idad de sus opera iones est garantizada, por ejemplo, desabilitando momentneamente el s heduler y a ve es tambin deshabilitando interrup iones (de hardware), ya
que estas ltimas podran rear una ondi in de arrera sobre el a eso a algn re urso.
lo k y unlo k y algunas opera iones de ontrol sobre thThread.wait y Thread.resume) es posible implementar todos los dems
Con primitivas omo

reads ( omo
me anismos de ms alto nivel, omo monitores y regiones rti as ondi ionales.
8.8. Con urren ia on pasaje de mensajes

Un sistema on urrente puede denirse omo un onjunto de omponentes (generalmente denominados pro esos) separados, ada uno on su memoria lo al (independiente) y que se omuni an entre s por medio de mensajes.
Este enfoque permite una mayor modulariza in de los programas y an una mayor
independen ia en la den in de ada uno de las partes del sistema. Cada omponente
podra implementarse en un lenguaje de programa in diferente siempre que todos
usen el mismo me anismo de transmisin de mensajes.
Estos sistemas tambin se ono en omo sistemas distribuidos ya que ada omponente podra eje utarse en su propio ambiente o sistema de omputa in.
El me anismo de transmisin de mensajes generalmente onsta de anales que
permiten inter one tar pro esos.
Un anal se one ta a un pro eso por medio de un puerto (port).
Un anal puede ser
Asin rni o:
un pro eso puede enviar mensajes por un anal y ontinuar on
su eje u in. Generalmente un pro eso que lee datos del anal deber esperar
(bloquear) hasta que el anal ontenga al menos un mensaje.
Este me anismo generalmente requiere que el anal disponga de un buer.
Asin rni o: un pro eso que desee enviar un mesaje deber esperar a que otro
pro eso reali e una le tura por el otro extremo. Este me anismo de pasaje de
mensajes a ta tambin omo me anismo de sin roniza in.
161
Con urren ia
En esta se in se des ribir un me anismo de pasaje de mensajes extendiendo el

modelo de larativo on dos opera iones primitivas adi ionales:
NewPort S P:
Send X P:
rea un nuevo puerto
on un stream (lista lazy)
enva un mensaje (valor ligado a)
X por el
puerto
S.
P.
La le tura de mensajes se ha e por el me anismo habitual de ligadura de variables.
lo al P S in
{NewPort S P}
thread for I in {Generator} do {Send I P} end end
thread for M in S do {Browse M} end end
end
Figura 8.7: Ejemplo de produ tor- onsumidor on mensajes y puertos.
La gura 8.7 muestra un ejemplo de una implementa in de un produ tor- onsumidor

on puertos.
8.8.1. Semnti a de los puertos

Para poder implementar los puertos es ne esario representarlos on la no in de
estado, ya que un puerto requiere de un identi ador. Se utilizar la memoria mutable
.
La senten ia
({NewPort <x><y>},E) realiza lo siguiente:
1. rea un nuevo identi ador (nombre)

2.
para el puerto,
Bind(E(<y>),n) y
3. si la ligadura tuvo xito, agregar el par
E(<y>):E(<x>) a ,
4. en otro aso, generar una ondi in de error (ex ep in).

La senten ia
({Send <x><y>},E) realiza los
1. si la ondi in de a tiva in de
siguientes pasos:
E(<x>) (E(<x>)
es determinada) es falsa
suspender la eje u in del thread, sino ha er los siguientes pasos:

2. si
E(<x>) no est ligado a
3. si
ontiene el par
un nombre de un puerto, generar un error, sino
E(<x>):z, enton es
ha er
z' en la memoria ,
E(<x>):z en on E(<x>):z',
lista de la forma E(<y>)|z',
a ) rear una nueva variable

b ) a tualizar el par
) rear una nueva
d)
Bind(z',z)
4. en otro aso, generar una ondi in de error (ex ep in).
162
Con urren ia
8.8.2. Proto olos de omuni a in entre pro esos

Pro esos (port obje ts) genralmente requieren omuni arse entre s de alguna forma
oordinada. Adems debern respetar formatos de mensajes para que ada uno de los
intervinientes en el sistema puedan re ono erlos y a tuar en onse uen ia.
Un proto olo de omuni a in dene di ha oordina in y los formatos de los mensajes. La oordina in se expresa generalmente omo se uen ias de mensajes en los
diferentes posibles es enarios del sistema. Generalmente esto se expresa por sistemas
de transi in de estados o diagramas de mensajes (o se uen ias).
En los sistemas distribuidos omo las redes, existen proto olos a diferentes niveles
del sistema. Por ejemplo, la familia de proto olos TCP/IP, dene 4 apas (niveles) de
proto olos en un sistema de omputa in. Al ms bajo nivel se en uentra el nivel de
enla e (data link layer), el ual dene la interfa e entre mensajes (datagramas) IP y
el hardware en argado de su transmisin y re ep in (ethernet, point-to-point, et ).
El nivel de red (network layer) se en arga de denir el me anismo de ruteo de envo
y re ep in de mensajes, deniendo identi adores (dire iones IP)para ada interfa e del sistema y otros me anismos de ontrol ( omo el proto olo ICMP). El nivel de
transporte (transport layer) dene dos proto olos de omuni a in donde los extremos
ya onsideran el on epto de puerto, lo que permite representar onexiones entre dos
pro esos (lo ales o remotos). Uno de los proto olos es UDP (User Datagram Proto ol),
el ual dene un modelo de envo y re ep in sin onexin y no brinda ningn servi io
de garantas de envo y re ep in. El segundo es TCP (Transmission Control Proto ol), el ual permite estable er una onexin (virtual) entre dos pro esos y garantiza
se uen ialidad en la transmisin de los mensajes (paquetes) y realiza retransmisiones
en aso de fallas.
Al mas alto nivel se en uentran denidas interfa es (APIs) para las apli a iones
que denen formatos para algunos tipos de datos, omo orden de bytes uniforme, y
brindan opera iones de estable imiento y ierre de onexiones y transisin y re ep in
de mensajes. Una de las APIs mas populares en TCP/IP es Berkeley so kets.
TCP/IP es la familia de proto olos usado en Internet.
La Organiza in Interna ional de Estndares (ISO) ha denido un modelo de referen ia para los proto olos de omuni a in que onsiste en siete apas.
Otros proto olos muy populares son RPC (Remote Pro edure Call) y RMI(Remote
Method Invo ation). RMI fue desarrollado por Sun en la d ada de 1980 y su objetivo es permitir desarrollar apli a iones en las uales el envo de mensajes tuviesen
el mismo signi ado que las invo a iones o llamadas a pro edimientos. Esto permite
eje utar servi ios de pro esos remotos omo si se tratara de una invo a in omn a
pro edimientos.
En estos ltimos proto olos, el proto olo en apsula las llamadas a pro edimientos
en mensajes que al ser re ibidos por el destinatario, se de odi an y se invo a al
pro edimiento aso iado.
RMI es la extensin del on epto on la no in de objeto.
163
Con urren ia
Los proto olos llamados web servi es son proto olos al estilo RPC o RMI, generalmente implementados sobre el proto olo HTTP, el ual fue diseado para la World
Web Wide en Internet.

Entre los proto olos que se usan ampliamente para implementar servi ios en internet, se pueden men ionar XML-RPC, SOAP, Java Servlets, Java Beans, Java RMI,
et .
Mu has empresas y omunidades de software libre ofre en familias de bibliote as
(frameworks) para el desarrollo de apli a iones distribuidas, omo CORBA, OLECOM, .Net, J2EE, et .
8.9. Deadlo k
El uso de me anismos de sin roniza in en el modelo on urrente on estado, trae
problemas adi ionales en el diseo e implementa in de programas on urrentes.
Es posible es ribir un programa en el ual varios omponentes a ediendo, en forma
ontrolada por me anismos de sin roniza in, a iertos re ursos podra al anzar un
estado en el ual dos o ms threads o pro esos podran quedar esperndose mutuamente
para a eder a los re ursos.
Este estado que imposibilita el progreso de omponentes de un sistema on urrente
se ono e omo deadlo k (abrazo mortal).
La gura 8.8 muestra un esquema de un programa en el que podra o urrir deadlo k.
T1 = thread
...
lo k X in
... (1)
lo k Y in
...
end
...
end
T2 = thread
...
lo k Y in
... (2)
lo k X in
...
end
...
end
Figura 8.8: Ejemplo de un programa on un poten ial deadlo k.
T1 puede estar en (1), es de ir que ya tiene a eso ex lusivo a X y el

T1 puede estar en (2), es de ir que ya obtuvo a eso ex lusivo a Y. A partir de
El thread
thread
all, ambos threads esperarn por siempre.

Para que exista la posibilidad de que o urra un deadlo k, se deben umplir las
siguientes ondi iones en forma simultnea:
ex lusin mutua:
los threads o pro esos a eden en forma ex usiva a los re-
ursos.
espera y reten in:
los threads esperan por un re urso mantienen el uso ex-
lusivo de otros que ya han adquirido on anterioridad.
164
Con urren ia
no quita de re ursos: ningn thread o pro eso puede quitar en forma ompulsiva un re urso a otro thread.
espera ir ular:
debe darse la situa in en que hay un i lo en la rela in de
requerimientos de re ursos que tratan de a eder los threads y los re ursos que
estn reteniendo. Esta rela in puede modelarse omo un grafo.
El programador de apli a iones, generalmente no tiene ontrol sobre las tres primeras ondi iones, ya que la primera es un requermiento para una solu in orre ta
del problema y las dos siguientes son ondi iones impuestas por el sistema.
Por lo tanto, generalmente, deber es ribir los programas de tal forma para evitar
la espera ir ular.
Esto se puede lograr si ada thread a ede a los re ursos en un determinado orden,
perdiendo tal vez, algn grado de on urren ia por el bloqueo temprano de re ursos
on respe to a su uso on reto.
8.10. Con urren ia en Java

El lenguaje de programa in Java ontiene fa ilidades de on urren ia ofre iendo
threads y algunos me anismos de sin roniza in omo lo ks y monitores.
Se puede denir un thread omo una lase derivada de
la interfa e
Runnable.
Thread
o implementando
Ambas t ni as requieren que se redena el mtodo
run(),
el
ual har de senten ia ini ial a eje utarse uando se ini ie el nuevo thread.
Cada objeto que sea un thread puede ser (o omportarse omo) un monitor.
Una senten ia (bloque) puede ha erse atmi a usando la palabra reservada
syn hronized.
Esta keyword tambin puede ser apli ada en la deni in de un mtodo, lo que ha e
que el mtodo se eje ute dentro del monitor del objeto. Esto no ha sido una de isin
muy a ertada en el diseo del lenguaje, ya que digo (ej: un mtodo) no sin ronizado
puede a eder a los atributos del objeto sin ontrol del monitor.
Un monitor en un objeto Java soporta las opera iones
wait() y notify()3.
Estas opera iones slo son posibles dentro de un monitor, es de ir en digo pro-
syn hronize.
tegido por
Las opera iones men ionadas ha en lo siguiente:
wait():
1. El thread orriente se suspende.
2. El thread es olo ado en la ola de threads suspendidos del objeto (wait
set).
3. Se libera el lo k sobre el objeto.
3 Tambin
existe la opera in notifyAll(), la ual desbloquea a todos los threads en ese monitor.
165
Con urren ia
notify():
1. Un thread
2.
T se
sa a de la ola de threads suspendidos (si hay alguno).
T intentar obtener el lo k. En este momento, T puede ompetir por el lo k

on otros threads.
3.
T ontina
La opera in
(resume) su eje u in normalmente.
notifyAll() ha e
lo mismo que
notify(),
slo que para todos los
threads en la wait set del objeto.
8.11. Ejer i ios

1. Dado el siguiente esquema de eje u in de threads:
i5
----> T3
i3 / i4
---->/----> T2
i0 / i1 i2
---->/---->---->
T1
a ) Dar el orden ausal (orden par ial de eje u in de las instru iones).
b ) Dar todos las posibles trazas de eje u in dadas por el interleaving.
2. Eje utar manualmente, siguiendo la semnti a del lenguaje on urrente de larativo del siguiente programa:
lo al X,Y in
X = 1
thread fun {$}
Y = X
X+1
end
end
thread fun {$} Y end end
{Browse X Y}
end
3. Implementar en Oz un pro edimiento
{Wait X} el ual debe

X se ligue.
ha er esperar (blo-
quear) al thread que lo eje uta hasta que

4. Implementar en Oz un pro edimiento
{Barrier [X1 X2 ... Xn} que
se om-
porte omo una barrera.

5. Implementar en Oz un programa que lea datos de la entrada estndar (stream)
y los muestre en la interfa e de usuario ( on Browse) a medida que se ingresan
y si luego de 1 minuto no se ingresa ningn valor, deber onsultar al usuario si
quiere ontinuar o no y a tuar en onse uen ia.
166
Con urren ia
6. Implementar en Oz un programa on un thread que genere una lista de nmeros

enteros (en un intervalo dado) y otro thread que los vaya sumando en forma
on urrente. Este problema es una instan ia del produ tor- onsumidor donde la
lista es un stream.
7. Modi ar el programa anterior adi ionando un nuevo thread que ltre los nmeros pares de la se uen ia generada y la suma se reali e sobre la lista ltrada.
Esto es una instan ia de un pipeline.
8. Modi ar el programa del ejer i io 6 para que ontenga un buer a otado (en
apa idad), utilizando on urren ia de larativa. El produ tor deber esperar para produ ir en el buer si ste est en su total apa idad y el onsumidor deber
esperar si el buer est va o.
9. Dado el siguiente programa C
#in lude <stdio.h>

#in lude <unistd.h>/* por getpid() */
#define N (2000)
int main(void)
{
FILE * f = fopen("seqno.txt","r+");
int i, value;
for (i=0; i<N; i++) {
fs anf(f,"%d", &value);
value++;
rewind(f);
fprintf(f,"%6d\n", value);
printf("Pro ess id: %d, value: %d\n", getpid(), value);
fflush(stdout); /* forzar la es ritura al ar hivo */
}
}
a ) Crear el ar hivo
seqno.txt onteniendo una ni a lnea
on un ero.
b ) Correr dos (o ms) instan ias del programa en forma se uen ial (ej:
; prog) y
) Correr dos (o ms) instan ias del programa en forma on urrente (ej:
& prog) y
prog
veri ar que la salida es la esperada.
prog
veri ar el resultado nal en el ar hivo.
d ) Existe una ra e ondition ? Justi ar.

10. Modi ar el programa anterior para que logre su objetivo uando se eje uta en
forma on urrente.
Ayuda: usar las fun iones de bibliote a
flo kfile() y funlo kfile().
167
Con urren ia
11. Un port obje t (o agente) es un objeto que ombina mltiples puertos on un

ni o stream. Esto permite la omuni a in entre pro esos de la forma mu hos
a uno. Los port obje ts son generalmente usuados para modelar e implementar
sistemas distribuidos. Un port obje t pro esa los mensajes que arriban por sus
puertos.
Implementar una apli a in del tipo mltiples es ritores, un le tor, el ual es
una instan ia del problema general de produ tores y onsumidores, usando port
obje ts.
12. Implementar un programa on urrente en Oz on estado que ontenga al menos
dos threads realizando a iones sobre una instan ia de la lase
Sta k denida en
este aptulo. Utilizar lo ks para atomizar las opera iones sobre el sta k.
13. Implementar en Oz y Java una lase
Semaphore
el ual se omporte omo los
semforos denidos en este aptulo.

14. Dada la siguiente lase Java, implementar el problema del produ tor- onsumidor
(o bounded buer). Denir las lases
Produ er
Consumer
que representen
threads produ iendo y onsumiendo valores a/desde una instan ia de
Buffer.
lass Buffer
int[ buf;
int first, last, n, i;
publi void init(int size) {
buf=new int[size;
n=size; i=0; first=0; last=0;
}
publi syn hronized void put(int x) {
while (i<n) wait();
buf[last=x;
last=(last+1)%n;
i=i+1;
notifyAll();
}
publi syn hronized int get() {
int x;
while (i==0) wait();
x=buf[first;
first=(first+1)%n;
i=i-1;
notifyAll();
return x;
}
}
15. Qu su edera si en la lase
notifyAll() por notify()?
Buffer
168
del ejer i io anterior se reemplaza ada
Con urren ia
16. Modi ar el programa Java del produ tor- onsumidor usando los semforos denidos anteriormente.
17. El problema de los lsofos omensales es un problema lsi o para el estudio
de deadlo ks. Existen
lsofos, los uales, repetitivamente, piensan por un
momento y luego toman dos tenedores que se en uentran al lado del plato y
omen, para nalmente dejar los tenedores nuevamente en la mesa.
Cada lsofo tiene un plato y hay
tenedores: uno entre ada plato.
a ) Des ribir un estado en que puede o urrir deadlo k.

b ) Es ribir un programa que modele el problema libre de deadlo k.
169
Captulo 9
Programa in Rela ional

Un pro edimiento en el modelo de larativo usa sus argumentos de entrada para
al ular los valores de los argumentos de salida. Desde un punto de vista matemti o
se podra ver esto omo un al ulo fun ional, en el sentido de que para un set de valores
de argumentos de entrada solo hay un set de valores de argumentos de salida.
El pro edimiento rela in es mas general y exible, dado que es posible dar ualquier numero de valores de salida ( ero si no hay resultado). Esta exibilidad resulta
apropiada para el desarrollo de apli a iones en reas omo Sistemas Expertos
1 , Pro-
esamiento del lenguaje humano, entre otras.

La programa in rela ional extiende la programa in de larativa on una nueva
senten ia llamada hoi e, la ual sele iona nodeterministi amente una de un set de
alternativas posibles.
La exibilidad de la programa in rela ional tiene algunas desventajas. Puede ondu ir a programas ine ientes si no se la utiliza apropiadamente. Cada nueva opera in
hoi e produ e un aumento exponen ial del espa io de bsqueda en bus a de solu iones. Es muy pr ti a uando el espa io de bsqueda es pequeo, no obstante suelen
utilizarse t ni as apropiadas de optimiza in, bsqueda utilizando heursti as o introdu iendo restri iones uando el espa io de bsqueda es onsiderable.
9.1. El modelo de Computa in Rela ional

9.1.1. Las senten ias hoi e y fail
El modelo omputa ional rela ional extiende el modelo de larativo introdu iendo
las senten ias hoi e y fail.
choice < s >1 [] . . . [] < s >n end.
Elige nodeterministi amente una de un
set de alternativas. Si la elegida llega a fallar enton es elige otra del onjunto.
Cada vez que ha e una ele in determina lo que se llama un punto de ele in.
Un punto de ele in es una parte de la mquina abstra ta que en apsula la
1 Un
sistema experto es un programa que imita el omportamiento de un experto humano.

170
informa in ne esaria para poder retro eder (ba ktra king ) en la eje u in y
elegir otra alternativa.
Fail. Indi a que la alternativa es erronea. Un fail es eje utado impl itamente
uando se intenta ligar dos valores in ompatibles (ej. 3=4).
Ejemplo:
fun {Soft} hoi e beige [ oral end end

fun {Hard} hoi e mauve [ o hre end end
pro {Contrast C1 C2}
hoi e C1 = {Soft} C2 = {Hard} [ C1 = {Hard} C2 = {Soft} end
end
fun {Suit}
Shirt Pants So ks
in
{Contrast Shirt Pants}
{Contrast Pants So ks}
if Shirt==So ks then fail end
suit(Shirt Pants So ks)
end
El siguiente programa ayuda a un diseador de ropa a elegir los olores olores para
el traje de un hombre. Soft elige un olor suave y Hard uno fuerte. Contrast es oge un
par de olores ontrastantes (uno suave y uno fuerte). Suit retorna un juego ompleto
de ombina in de olores para un traje ex epto aquellos en los que oin ida la amisa
on los al etines.
9.1.2. Arbol de Bsqueda

Un programa rela ional es eje utado se uen ialmente. En parti ular la senten ia
hoi e va eligiendo las alternativas en el orden que ellas son en ontradas (de izquierda
a dere ha). Cuando un fail es eje utado, se produ e un retro eso de la eje u in a
la ltima alternativa elegida del hoi e, el ual elige la proxima alternativa, y asi
su esivamente. Esta estrategia puede ser ilustrada on un arbol de busqueda (ver gura
9.1).
9.1.3. Bsqueda En apsulada

Un programa rela ional es interesante porque este puede eje utarse poten ialmente
de mu has maneras, dependiendo de las ele iones del hoi e. Por lo tanto se debe dar
un ontrol sobre uales alternativas son elegidas y uando. Por ejemplo, ual estrategia
de bsqueda podra apli ar: depth-rst sear h, breadth-rst sear h, o alguna otra. Tambin se debe espe i ar sobre omo y uantas solu iones son retornadas: una solu in,
todas las solu iones, solu iones bajo demanda.
171
Figura 9.1: rbol de Bsqueda para el ejemplo del diseador de ropa.
172
Una manera de llevar a abo este ontrol es mediante bsqueda en apsulada. La

en apsula in signi a que el programa rela ional se eje uta dentro de una lase de
'environment'. Un programa rela ional puede produ ir mltiples binding de la misma
variable uando diferentes ele iones son efe tuadas. Estos mltiples bindings no deben ser visibles al resto de la apli a in. La busqueda en apsulada tambien es muy
importante para la modularidad y omposi ionalidad:
Modularidad : permite que se puedan eje utar mas de un programa rela ional
on urrentemente.
Composi ionalidad : un bsqueda en apsulada puede eje utarse dentro de otra

bsqueda en apsulada.
Lenguajes mas viejos omo Prolog tienen ba ktra king global, multiples binding son
visibles al resto de la apli a in, lo ual no es bueno para los on eptos men ionados
anteriormente.
9.1.4. La fun in Solve

La fun in Solve toma una fun in sin argumentos y retorna una solu in a un
programa rela ional omo una lista lazy de todas las solu iones, ordenadas de a uerdo
a la estrategia depth-rst sear h. Por ejemplo la llamada:
L={Solve fun {\$} hoi e 1 [ 2 [ 3 end end}

retorna la lista lazy [1,2,3, dado que Solve es lazy, es de ir solo al ula las solu iones
que son ne esitadas. Solve es omposi ional, es de ir, puede ser anidada (la fun in F
puede ontener llamadas a Solve ). Se puede denir ahora las opera iones: one-solution
sear h y all-solutions sear h.
fun {SolveOne F}
L={Solve F}
in
if L==nil then nil else [L.1 end
end
fun {SolveAll F}
L={Solve F}
pro {Tou hAll L}
if L==nil then skip else {Tou hAll L.2} end
end
in
{Tou hAll L}
L
end
Ejemplos:
173
fun {Digit}
hoi e 0 [ 1 [ 2 [ 3 [ 4 [ 5 [ 6 [ 7 [ 8 [ 9 end
end
{Browse {SolveAll Digit}}
Devuelve: [0 1 2 3 4 5 6 7 8 9
9.2. Programa in Rela ional a Lgi a

Tanto el modelo omputa ional de larativo omo el rela ional estn muy ligados a
la programa in lgi a. En la programa in lgi a los programas tienen dos semnti as, una lgi a y una opera ional. Sin embargo la programa in lgi a no puede ser
usada para todos los modelos omputa ionales.
El paradigma lgi o, que result una gran novedad en la d ada del 70, tiene omo
ara tersti a diferen iadora el he ho de manejarse de manera de larativa y on la
apli a in de las reglas de la lgi a. Esto signi a que en lugar de basarse, omo en el
aso de los paradigmas pro edurales, en el planteo del algoritmo para la resolu in del
problema, se basa en expresar todas las ondi iones del problema y luego bus ar un
objetivo dentro de las de lara iones realizadas. Esta forma novedosa de tratamiento
de la informa in llev a pensar en un determinado momento en la revolu in que signi ara la existen ia de 'programas inteligentes' que pudieran responder, no por tener
en la base de datos determinados ono imientos, sino por poder inferirlos a travs de
la dedu in.
Existe toda una gama de lenguajes que siguen este paradigma, aunque la mayora de
ellos estn basados en el lenguaje PROLOG.
Para nuestro propsito un programa lgi o onsiste de un set de axiomas en el al ulo
de predi ados de primer orden, una senten ia llamada onsulta (query ) y un probador
de teoremas, es de ir, un sistema que puede realizar dedu iones usando los axiomas
a n de probar o desaprobar una onsulta (eje u in de un programa lgi o).
Un sistema de estas ara tersti as debe abordar los siguientes problemas:
Un probador de teoremas es limitado en lo que ste puede ha er. No garantiza
en ontrar una prueba o una desaproba in de un query en ualquier modelo.
In luso en aquellos asos en donde es posible en ontrar pruebas, puede ser ine iente. La bsqueda para una prueba puede tomar un tiempo exponen ial.
La dedu in efe tuada por el probador de teoremas debe ser onstru tiva. En
los asos en que un query es satisfe ho por la existen ia de algn x que umple
la propiedad, enton es el sistema debe onstruir tal testigo.
Dos posibles a er amientos para solu ionar estos problemas son in orporando restri iones sobre los axiomas y dando al programador la posibilidad de proveer ayuda
al probador de teoremas on ono imiento opera ional. El primer lenguaje en in orporar estos a er amientos fue Prolog, luego fue subse uentemente seguido por otros
lenguajes.
174
9.2.1. Semnti a Opera ional y Lgi a

Hay dos maneras de mirar un programa lgi o: mediante una vista lgi a y una
opera ional. La vista lgi a es simplemente una senten ia de la lgi a. La vista opera ional dene una eje u in sobre una omputadora.
Los programas en el modelo de larativo tienen tanto una semnti a lgi a omo opera ional. Es dire to tradu ir un programa de larativo en una senten ia lgi a. Si el
programa termina orre tamente, es de ir, no se bloquea, no entra en un loop innito,
o no surge una ex ep in, enton es todos los bindings son dedu iones orre tas desde
los axiomas.
La tabla de la gura 9.2 dene un esquema de tradu in T el ual tradu e ualquier senten ia
<s>
en el lenguaje kernel rela ional en una forma lgi a
T (< s >).
La deni in de pro edimientos son tradu idas en deni iones de predi ados. Las ex ep iones no son tradu idas.
Figura 9.2: Tradu in de un Programa Rela ional a Frmula Lgi a.

Una semanti a lgi a dada puede orresponder a mu has semnti as opera ional.
Por ejemplo las siguientes 3 senten ias:
X=Y <s>
<s> X=Y
if X==Y then s else fail end
175
tienen exa tamente la misma semnti a lgi a:
X = Y T (s),
pero sus semanti as
opera ionales son muy diferentes. Es ribir un programa lgi o onsiste de 2 partes:
es ribir la semanti a lgi a y enton es elegir una semnti a opera ional para esta. El
arte de la programa in lgi a es ha er un buen balan eo entre una simple semnti a
lgi a y una e iente semnti a opera ional.
Ejemplo: Deterministi Append
fun {Append A B}
ase A
of nil then B
[ X|As then X|{Append As B}
end
end
Tradu ido a un pro edimiento:
pro {Append A B ?C}

ase A of nil then C=B
[ X|As then Cs in
C=X|Cs
{Append As B Cs}
end
end
De a uerdo a la tabla de la gura 9.2 , este pro edimiento tiene la siguiente semnti a lgi a:
a, b, c : append(a, b, c) (a = nil c = b) ( x, a , c : a = x|a c = x|c

append(a, b, c))
La semnti a opera ional esta dada por la semnti a del modelo de larativo.
La llamada {Append [1 2 3 [4 5 X} se eje uta satisfa toriamente y retorna X=[1,2,3,4,5.
La frmula lgi a de una llamada sera la tupla append([1,2,3,[4,5,x). Luego de la
eje u in la tupla queda append([1,2,3,[4,5,[1,2,3,4,5). Esta tupla es un miembro
de la rela in append . Vemos que el pro edimiento Append puede ser visto omo un
programa lgi o.
El modelo rela ional provee una forma de programa in lgi a nodeterministi a
muy pare ida a la que provee Prolog. Mas pre isamente es un sub onjunto de Prolog
llamado 'pure Prolog'. Los programas es ritos en el modelo de omputa in rela ional
y pure Prolog tiene una tradu in dire ta, on las siguientes diferen ias:
Prolog usa lausulas de Horn omo sintaxis on una semnti a opera ional basada en el prin ipio de resolu in.
Programa in Higher-order no es soportada en pure Prolog.
El modelo rela ional distingue entre opera iones deterministi as (sin usar hoi e)
y opera iones nodeterministi as (usando hoi e). En pure Prolog ambas tienen
176
la misma sintaxis, las opera iones determinsti as realizan l ulos fun ionales,
mientras que las no deterministi as l ulos rela ionales.
9.3. Prolog
Es un lenguaje de programa in ideado a prin ipios de los aos 70 en la universidad
de Aix-Marseille por los profesores Alain Colmerauer y Phillipe Roussel. Ini ialmente se trataba de un lenguaje totalmente interpretado hasta que, a mediados de los
70, David Warren desarroll un ompilador apaz de tradu ir Prolog en un onjunto de instru iones de una mquina abstra ta denominada Warren Abstra t Ma hine
(WAM). Desde enton es Prolog es un lenguaje semi-interpretado.
Los programas en Prolog se omponen de lusulas de Horn que onstituyen reglas
del tipo 'modus ponens'. No obstante, la forma de es ribir las lusulas de Horn es al
ontrario de lo habitual. Primero se es ribe el onse uente y luego el ante edente. El
ante edente puede ser una onjun in de ondi iones que se denomina se uen ia de
objetivos. Cada objetivo se separa on una oma y podra onsiderarse similar a una
llamada a pro edimiento de los lenguajes imperativos. En Prolog no existen instru iones de ontrol.
Su eje u in se basa en dos on eptos: la uni a in y el ba ktra king.
Gra ias a la uni a in, ada objetivo determina un sub onjunto de lusulas sus eptibles de ser eje utadas. Cada una de ellas se denomina punto de ele in. Prolog
sele iona el primer punto de ele in y sigue eje utando el programa hasta determinar
si el objetivo es verdadero o falso. En aso de ser falso entra en juego el ba ktra king,
que onsiste en desha er todo lo eje utado situando el programa en el mismo estado
en el que estaba justo antes de llegar al punto de ele in. Enton es se toma el siguiente punto de ele in que estaba pendiente y se repite de nuevo el pro eso. Todos los
objetivos terminan su eje u in bien en xito ('verdadero'), bien en fra aso ('falso').
9.3.1. Elementos Bsi os

Un programa Prolog podra verse omo la representa in de un universo nito
en forma de he hos y reglas ( hipotesis y axiomas ), on el objetivo de en ontrar
solu iones en di ho universo. Para ello debemos ontar on una gramti a ade uada,
uyos elementos (trminos) son los siguientes:
Smbolos de Variables :
representan objetos ualesquiera del universo. Comienzan siempre on mays ulas. Ejemplos de variables son: L, L2, Persona, _ (variable annima). Una
variable puede estar ligada uando existe algn objeto representado por ella, o
no ligada en aso ontrario.
Predi ados y fun iones :

La sintaxis de ambos es la misma. Ejemplos de ellos son:
177
padre_de(juan, berta), ama(maria, X), suma(se esor(0), X, 2),...

Sin embargo aunque idnti os en su sintaxis dieren on eptualmente, ya que
una fun in nos devuelve un valor: su esor(0) tiene omo referente el valor 1, en
ambio un predi ado des ribe una propiedad o una rela in entre sus elementos,
ya que pueden ser verdaderas o falsas.
Una ara tersti a fundamental del Prolog es que en el fondo todos los trminos
pueden redu irse a predi ados: en Prolog todo son predi ados.
Atomos :
Las estru turas de tipo predi ado tambin se denominan tomos. Se di e que un
tomo es errado uando sus argumentos son variables ligadas, y que no lo es
uando tiene un argumento sin ligar.
Listas :
Una lista est formada por un primer elemento (head ) mas una lista (tail ).
Ejemplos:
[ (lista va a, tambin llamada 'nil'), [A, B, C, [Cabeza|Resto
9.3.2. Clusulas Prolog

Las lausulas son estru turas que permiten representar he hos, preguntas o onsul-
tas y reglas.
Un he ho es algo que siempre es verdadero en un determinado universo. La sintaxis
de los he hos y las preguntas es la misma. Ejemplo:
Programa 1:
1.es_padre(tera h, abraham).
2.es_padre(tera h, na hor).
3.es_padre(tera h, haran).
4.es_padre(abraham, isaa ).
5.es_padre(haran, lot).
6.es_padre(haran, mil ah).
7.es_padre(haran, yis ah).
8.es_madre(sarah, isaa ).
9.es_hombre(tera h).
10.es_hombre(abraham).
11.es_hombre(na hor).
12.es_hombre(haran).
13.es_hombre(isaa ).
14.es_hombre(lot).
15.es_mujer(sarah).
16.es_mujer(mil ah).
17.es_mujer(yis ah).
Toda lausula de prolog ha de terminar on un punto.

Todos los he hos anteriores son he hos de base (sin variables), pero tambin se pueden
introdu ir he hos on variables omo axiomas, por ejemplo: suma(0, X, X). En ellos,
las variables se onsideran uanti adas universalmente. Es de ir,
x : suma(0, x, x).
Al igual que el he ho es_mujer(sarah) estable e la verdad de la senten ia 'Sarah

es mujer', el he ho suma(0, X, X) estable e la verdad para ualquier valor que pueda
tomar la variable, es de ir, nos di e que 'para todo trmino x, la suma de 0 on x es x' .
178
Equivale a un onjunto de he hos de base omo seran: suma(0, 1, 1), suma(0, 2, 2), et .
A un programa PROLOG se le ha en preguntas. Una pregunta se es ribe omo:

?A1, A2, . . . , Am. siendo
m > 0. Informalmente, di ha pregunta se leer: 'Son iertos
los he hos A1 y A2 y . . . y Am?'.
Por ejemplo, se puede ha er onsultas al Programa 1 del siguiente tipo:
PREGUNTA
SIGNIFICADO
?es_padre(abraham,isaa ).
es padre Abraham de
S, pues en uentra
RESPUESTA
Isaa ?
un he ho que lo
satisfa e.
?es_padre(abraham,lot).
es padre Abraham
No,
de Lot?
pues no hay ningn

he ho que lo arme.
? es_padre(haran,X).
existe un X tal que
S, dando todas las
es padre Haran de X?
solu iones posibles:

X=lot ; X=mil ah
;X=yis ah.
Las reglas son estru turas omplejas ompuestas por varios tomos. Constan de
dos pares: una abeza, formada por slo tomo; y un uerpo, en el que pueden apare er
varios tomos. Adems de las reglas entran en juego los operadores lgi os que son
la onjun in (representada por las omas que separan los tomos del uerpo ), y la
disyun in, que puede es ribirse de 2 maneras: separando on punto y oma los tomos
del uerpo, o poniendo ada miembro de la disyun in en una lusula aparte.
Ejemplo:
Una regla que expresa la rela in de ser hijo es: es_hijo(X,Y) :- es_padre(Y,X),
es_hombre(X). que se leera de la forma:'para todo X e Y, X es hijo de Y si Y es padre
de X y X es hombre', on lo que sirve para denir una nueva rela in a partir de otras.
NOTA: Esta regla representa la frmula: xy((es_padre(y, x) es_hombre(x))
es_hijo(x, y)). De igual forma se deniran otras rela iones mediante reglas: es_hija(X,Y):es_padre(Y,X),es_mujer(X). es_abuelo(X,Z):- es_padre(X,U), es_padre(U,Z).
El smbolo (:-) se lee omo una impli a in lgi a, pero al revs, es de ir, si el uerpo de la lusula es verdadero enton es la abeza es verdadera. Podramos enton es
es ribir los he hos omo:
madre(gea, cronos) : true.
179
Debemos rearmar que en Prolog todo es predi ado, ya que los operadores lgi os
lo son. As podramos es ribir en nota in preja: :-(A,B), en lugar de A:-B.
Con estas tres nuevas rela iones entre objetos y los he hos de base del Programa 1
se puede rear el siguiente Programa 2.
Programa 2:
18.es_hijo(X,Y):- es_padre(Y,X), es_hombre(X).
19.es_hija(X,Y):- es_padre(Y,X), es_mujer(X).
20.es_abuelo(X,Z):- es_padre(X,Y), es_padre(Y,Z).
Algunas onsultas que se pueden efe tuar al programa 2 son:
? es_hijo(lot,haran).
Respuesta: S, este he ho puede dedu irse, ya que segn la regla
18 es equivalente a preguntar:
?es_padre(haran,lot),es_hombre(lot).
? es_hija(X,haran).
(existe un X tal que es hija X de Haran?)
Respuesta: Segn la regla 19 es equivalente a preguntar

? es_padre(haran,X), es_mujer(X). por lo que el programa
ontestar que S, dando las solu iones: X=mil ah ; X=yis ah.
9.3.3. Fundamentos Lgi os de Prolog

Hay dos elementos esen iales a la base del Prolog: las lusulas de Horn y el prin-
ipio de resolu in de Robinson.
9.3.3.1. La forma Clausal y las lusulas de Horn

Prolog se sustenta en la lgi a de predi ados de primer orden, sin embargo no
utiliza esta lgi a en la forma que la ono emos, sino en lo que se denomina la forma
lausal. En este formalismo ontamos on los siguientes elementos:
Constantes.
Variables. De forma impl ita todas las variables estn uanti adas universalmente.
Predi ados.
Fun iones.
180
Los predi ados y fun iones se denominan literales y pueden ser de dos tipos: litera-
les armados (PERSONA(x)), y literales negados (CASADO(juan)). Los literales se

ombinan para formar expresiones mas omplejas denominadas lusulas. Pero para
llevar esto a abo se ne esitan las siguientes one tivas lgi as: nega in (), dis-
yun in ( |), y onjun in. Esta ltima no se representa expl itamente pero uando
tenemos un onjunto de lusulas, stas estn rela ionadas impl itamente mediante
onjun in.
No se ne esitan mas one tivas lgi as dado que el impli a y oimpli a pueden defnirse
en trminos de los anteriores.
AB
puede denirse omo
A|B.
ABU ELO(X, Y ) : P ADRE(X, Z), P ADRE(Z, Y ) es lgi amente equivalente a

P ADRE(z, y)|P ADRE(x, z)|ABU ELO(x, y)
(por la regla anterior y por ley de morgan) a
Hay un tipo de lusulas que resulta espe ialmente ade uado para la prueba de
teoremas on el prin ipio de resolu in. Son las lausulas de Horn. Se denen omo
aquellas lusulas que tiene omo mximo un literal no negado. De ello se desprende
que hay dos tipos de lusulas de Horn :
En abezadas: tienen un literal no negado. En prolog son las lusulas que usamos
para expresar las reglas y los he hos.
No en abezadas: todos sus literales son negados. En prolog las utilizamos para
formular las preguntas, o di ho de otra forma, son los teoremas que queremos
probar (:
es_hija(X, haran).).
Para resolver problemas de prueba de teoremas se onsideran onjuntos de lausulas

de Horn tales que una de ellas est sin en abezar y el resto en abezadas, debido a la
forma en que trabaja el prin ipio de resolu in que veremos a ontinua in.
9.3.3.2. El Prin ipio de Resolu in

A B y A C se deriva la
BC , donde las letras son literales. Las dos primeras lusulas son los axiomas
Este prin ipio de inferen ia puede formularse omo: de

lusula
o hiptesis y las que se van obteniendo de ellas, teoremas o resolventes, de los uales
pueden ser utilizados para obtener nuevos resolventes. Hay dos asos parti ulares de
esta ley:
A B
de
y de
y de
se deriva
(modus ponens).
se deriva la lausula va a ([]).
Esto ha e que el prin ipio de resolu in fun ione bien omo mtodo de redu in
al absurdo. As, dado un onjunto onsistente de axiomas, se puede probar un teorema
(nuestro objetivo, que es una lusula sin en abezar) negndolo en el punto de partida y pro ediendo a llevar a abo la resolu in de dos en dos lusulas, eliminando
de ambas los literales que ' oin idan', on la ni a diferen ia de que en una de las
lusulas el literal ha de estar armado y en la otra negado, o tal omo se en ontrara
en prolog, que en una lusula se en uentre a la izquierda del :- ( abeza ), y en la otra a
181
la dere ha ( uerpo ). Esta ' oin iden ia' de dos literales uno armado y el otro negado,
se denomina
uni a in
(ver prxima se in), y dar lugar a una nueva lusula
resolvente que podr utilizarse en un paso posterior. Si se onsigue llegar a la lusula

va a, se habr probado el objetivo.
Ejemplo:
1.P ADRE(jorge, juan)
2.HERM AN A(rita, juan)
3.SOLT ERA(rita)
Estos he hos ontienen gran antidad de informa in impl ita que se usara para
resolver este problema intuitivamente, por ejemplo, que 'juan' es varn, pero un probador de teoremas ne esita que toda la informa in aparez a de forma expl ita, por
lo que debe espe i arse:
4.SOLT ERO(x)|P ADRE(y, x)|M ISM OAP ELLIDO(y, x)
5.HERM AN A(x, y)|P ADRE(z, y)|P ADRE(z, x)
6.M ISM OAP ELLIDO(x, y)|M ISM OAP ELLIDO(y, z)|M ISM OAP ELLIDO(x, z)
7.P ADRE(x, y)|P ADRE(y, x)|V
ARON (y)|HIJO(y, x)
8.HIJO(x, y)|M ISM OAP ELLIDO(x, z)

9.V
ARON (juan)
Por ultimo se niega lo que queremos probar:

10.M ISM OAP ELLIDO(juan, rita)
Se podra empezar a resolver esto por ualquier lusula, pero hay aminos mas
ortos que otros para llegar a la on lusin. Aqu se elige el mas orto. Por la lusula
5 y teniendo en uenta que las variables esta uanti adas universalmente, seguir
siendo verdad que si rita es hermana de juan y jorge es el padre de juan, enton es
jorge es el padre de rita. Lo ni o que se ha he ho es sustituir las variables por valores

on retos. Este resultado es el que obtenemos on las lusulas 1, 2 y 5, sustituyendo
las variables de 5 por lo valores que apare en en 1 y 2, apli ando modus ponens, y
efe tuando la
uni a in.
11.P ADRE(jorge, rita)

Siguiendo el mismo pro eso de 3, 4 y 11 se deriva:
12.M ISM OAP ELLIDO(jorge, rita)
13.HIJO(juan, jorge) //de 1, 7 y 9
14.M ISM OAP ELLIDO(juan, jorge)// de 8 y 13
15.M ISM OAP ELLIDO(jorge, rita) // de 6, 10 y 14
Pero en 12 de a justamente lo ontrario, por lo que se ha llegado a una ontradi in.
16.[]
Por lo tanto se on luye que juan y rita tienen el mismo apellido.
182
Este razonamiento puede resumirse de la siguiente manera: para probar la existen ia de algo, suponer lo ontrario y usar modus ponens y la regla de elimina in del
uanti ador universal, para en ontrar un ontra ejemplo al supuesto. El objetivo es
onvertido en un onjunto de tomos a ser probados. Para ello, se sele iona un literal
del objetivo
p(s1, ..., sn)
p(t1, ..., tn) : A1, ...An para enp(s1, ..., sn) y p(t1, ..., tn), es de ir, una sustitu in
p(t1, ..., tn) sean idnti os. Tal sustitu in se ono e omo
y una lusula de la forma
ontrar una instan ia omn de

que ha e que
uni ador.
p(s1, ..., sn)
El nuevo objetivo se onstruye remplazando el tomo sele ionado en el
original, por los tomos de la lusula sele ionada, apli ando a todos los tomos obtenidos de esta manera.
El paso de omputa in bsi o, puede verse omo una regla de inferen ia puesto
que transforma frmulas lgi as y se denomina prin ipio de resolu in SLD.
Observar que generalmente, la omputa in de estos pasos de razonamiento no
es determinista: ualquier tomo de la meta puede ser sele ionado y pueden haber
varias lusulas del programa que uniquen on el tomo sele ionado. Otra fuente
de indeterminismo es la existen ia de uni adores alternativos para dos tomos. Esto
sugiere que es posible onstruir mu has solu iones (algunas ve es, una antidad innita
de ellas). Por otra parte, es posible tambin que el tomo sele ionado no unique on
ninguna lusula en el programa. Esto indi a que no es posible onstruir un ontra
ejemplo.
9.3.3.3. Uni a in y Regla de Resolu in

El mputo que PROLOG realiza para ontestar a una pregunta (a un programa
dado) se basa en los on eptos de uni a in y resolu in.
Uni a in
Para denir la uni a in formalmente son ne esarias algunas deni iones previas:
Deni in 9.3.1
Una
sustitu in es un onjunto nito de pares de la forma {v1
t1, v2 t2, . . . , vn tn},
donde ada vi es una variable, ada ti es un trmino
(distinto de vi) y las variables vi son todas distintas entre s.

Cuando se apli a una sustitu in a una expresin (regla, he ho o pregunta) se
obtiene una nueva expresin, reemplazado en la expresin original ada apari in de
(1 i n).
c = es_padre(Y, X), es_hombre(X), y la
in s = {Y haran, X lot}, la pregunta obtenida al apli ar s a c ser:
c s = es_padre(haran, lot), es_hombre(lot).
la variable vi por el trmino ti
Por ejemplo, dada la pregunta
Deni in 9.3.2
s ,
se dene la opera in de omposi-
s s de la siguiente forma:
s = {v1 t1, v2 t2, . . . , vn tn}
in
Si
Dadas dos sustitu iones
sustitu-
s = {w1 t 1, w2 t 2, . . . , wn t n},
183
enton es
s s = {v1 t1s , v2 t2s , . . . , vn tns , w1 t 1, w2 t 2, . . . , wn

t n} {vi tis |vi = tis } {wj t j|wj {v1, . . . , vn}}
La opera in de omposi in es aso iativa y tiene omo elemento neutro la sustitu in va a que se denota . Adems, dada una expresin y dadas dos sustitu iones
s y s' se veri a: (c s) s = c (s s ).
c = es_padre(Y, X), es_hombre(X) y las sustitu= {Z haran, X juan}, la pregunta obtenida
al apli ar primero s a c y despus s al resultado ser:
(c s) s = (es_padre(Z, lot), es_hombre(lot))s = es_padre(haran, lot), es_hombre(lot)
que puede ser obtenida omo c (s s ) ya que s s = {Y haran, X lot, Z

haran}
Por ejemplo, dada la pregunta
s = {Y Z, X lot} y s
iones
Un uni ador de dos tomos

es de ir, 's uni a o iguala
p(X, f (Z)).
c1
c1 y c2,
c2'. Por
ejemplo, dado
Los siguientes son uni adores de
s1 = {X a, Y f (a), Z a}
s tal que c1 s = c2 s,
c1 = p(a, Y ) y dado c2 =
es una sustitu in
ya que
s2 = {X a, Y f (f (a)), Z f (a)}
c1
c2:
c1 s1 = c2 s1 = p(a, f (a)).
ya que
c1 s2 = c2 s2 = p(a, f (f (a))).
c1 y c2 es el uni ador g de ambos

s de c1 y c2 se puede obtener omo la omposi in de
sustitu in u, es de ir s = g u. El uni ador ms general de dos
Un uni ador ms general (umg ) de dos tomos

tal que, ualquier uni ador
on alguna otra
tomos es ni o (salvo renombramiento de variables).

En el ejemplo anterior el umg de c1 y c2 sera: g = {X a, Y f (Z)} on
c1 g = c2 g = p(a, f (Z)).
El resultado p(a, f (Z)) obtenido tras apli ar g , es una expresin ms general que
obtenida apli ando s1, p(a, f (a)), o la obtenida apli ando s2, p(a, f (f (a))).
la
Existe un algoritmo para de idir si dos tomos son uni ables (esto es, si existe
para ellos algn uni ador). Este algoritmo siempre termina. Si los tomos son uni ables el algoritmo devuelve el umg de ellos, en otro aso, devuelve 'fra aso'.
En el algoritmo se utiliza la no in de ' onjunto de disparidad' de dos tomos, denido omo el onjunto formado por los dos trminos que se extraen de di hos tomos
a partir de la primera posi in en que dieren en un smbolo. Por ejemplo, el onjunto
de disparidad de
de disparidad de
p(X, f (Y, Z)) y p(X, a) es D = f (Y, Z), a,

p(X, f (Y, Z)) y p(X, f (a, b)) es D = Y, a.
Algoritmo de Uni a in Entrada: dos tomos

o
f racaso
Algoritmo:
g := set va io
fra aso := falso
184
c1
c2
mientras que el onjunto
Salida: el umg
de
c1
c2
mientras 1 g <> 2 g y no (fra aso)

al ular onjunto de disparidad D de 1 g y 2 g
si existe en D una variable V y un trmino t tal que V no apare e en t
g := g * {V --> t}.
sino
fra aso := ierto
fin-si
fin-mientras
if fra aso
devolver fra aso
else
devolver g
fin-si
end.
Ejer i io: Uni ar
{f (X, h(Z), h(X)), f (g(a, Y ), h(b), h(Y ))}
Estrategia de Resolu in usada en PROLOG

Dado un programa PROLOG omo onjunto de he hos y reglas, y dada una pregunta a di ho programa, el mputo que se realiza es apli ar paso a paso la regla de
resolu in on los he hos y/o reglas del programa hasta onseguir que en alguno de
esos pasos queden eliminados todos los nes de la pregunta (es de ir, hasta llegar a la
pregunta va a). En on reto, el pro edimiento a seguir es el siguiente:
?A1, A2, . . . , An. se bus ar la primera senten ia del

A1 y B sean uni ables por un umg g . PROLOG
senten ias uya abeza B se uni a on A1) la primera
Dada una pregunta de la forma

programa
B : B1, . . . , Bm. tal
elige (de entre las posibles
que
introdu ida en el programa.

Por tanto, el orden en que se introdu en las senten ias de un programa es signi ativo,
entre otras osas determinar el orden de las respuestas. Enton es la nueva pregunta
(el resolvente) ser
?(B1, . . . , Bm, A2, . . . , An) g .
El pro eso ontinuar de igual forma hasta obtener la pregunta va a (lo que orresponde a un xito ), o una pregunta para la ual no exista resolvente on ninguna senten ia del programa (lo que orresponder a un fra aso ). Esta estrategia de resolu in
que sigue PROLOG se denomina
estrategia de resolu in SLD.
La se uen ia de
pasos desde la pregunta original hasta la pregunta va a se llama refuta in SLD.

Ejemplo, onsiderando el Programa 2.
Pregunta :
?es_hijo(lot, haran).
Como se ha llegado a la pregunta va a (se ha en ontrado una refuta in), el he ho
es_hijo(lot, haran)
se dedu e del programa, por lo que PROLOG ontesta
185
s.
Figura 9.3: Estrategia de Resolu in SLD.
En ada paso del pro eso de resolu in se obtiene un uni ador ms general (umg ).
La omposi in de todos estos uni adores da lugar a las ligaduras que han tomado
las variables nalmente para llegar a la respuesta. En el ejemplo:
g1 = umg(es_hijo(lot, Z), es_hijo(X, Y )) = {X lot, Y Z}

g2 = umg(esp adre(Z, lot), esp adre(haran, lot)) = {Z haran}
g3 = umg(esh ombre(lot), esh ombre(lot)) =
Las ligaduras de las variables nalizado el pro eso, vienen dadas por la omposi in
de
g1, g2
g3: g = g1 g2 g3 = {X lot, Y haran, Z haran}.
Si de este
onjunto de ligaduras nos quedamos slo on las orrespondientes a las variables de la

pregunta original, obtenemos la respuesta dada por PROLOG:
Z = haran.
Re orrido en el Espa io de Bsqueda

PROLOG es apaz de dar todas las posibles respuestas a una pregunta, es de ir,
bus ar todas las posibles refuta iones SLD. El espa io de bsqueda de solu iones se
puede representar mediante un rbol, donde ada rama representa una posible refuta in SLD. En lugar de expresar en ada paso de resolu in la pregunta a tratar y la
senten ia on la que se resuelve, tal y omo vimos en el apartado anterior, se indi ar
ni amente el nmero de la senten ia on la que se resuelve di ha pregunta, tal y omo
se muestra en la gura 9.4.
Las respuestas a las dos refuta iones vienen dadas por las ligaduras de las variables
en ada rama.
186
Figura 9.4: Re orrido en el espa io de bsqueda.
g = g1 g12 g121 = {X milcah, Y haran, Z milcah}

Z = milcah.
que restringido
a las variables de la pregunta da omo respuesta
g = g1 g13 g131 = {X yiscah, Y haran, Z yiscah}

Z = yiscah.
que restringido a
las variables de la pregunta da omo respuesta

Por tanto, el sistema ontesta:
Z = milcah; Z = yiscah
El re orrido en el rbol es en profundidad y on 'vuelta atras' (ba ktra king ) a la

ltima ele in he ha (ver gura 9.5 para el ejemplo anterior).
9.3.4. Predi ado ut (!)

Prolog dispone del orte (!) omo mtodo para podar la bsqueda y aumentar la
e ien ia de los programas, es de ir, se lo utiliza para ortar el ba ktra king.
Ejemplo:
rel :- a, b, !, .
rel:- d.
Se indi a al interprete que solo busque la primera solu in que en uentre para las
sub onsultas
b.
En ambio para
podr bus ar mltiples solu iones. Cuando
187
Figura 9.5: Re orrido en el espa io de bsqueda on Ba ktra king.
en uentra un ut inhibe tambin la evalua in de otra lusula que dena la misma

rela in. En este aso la segunda lusula que dene a
rel
solo ser evaluada en aso
de que no se llegue a evaluar el ut en la primera.
9.3.5. Problema de la Nega in

Los programas expresan ono imiento positivo y no di en nada a er a del resto. De
esta forma ni amente es ierto aquello que est en el programa o que sea onse uen ia
lgi a del mismo.
Bajo esta hiptesis todo aquello que no est en el programa y que no pueda ser derivado a travs de sus reglas es FALSO y por lo tanto su nega in ( metapredi ado not
)es ierta. Esta arma in impli a que el uso in orre to puede resultar peligroso.
Ejemplo: 'Un piloto sui ida es todo aquella persona que ondu e y es irresponsable'
e 'irresponsable es toda persona que no es responsable'.
Una posible tradu in a un programa sera:
piloto_sui ida(X):- ondu e(X), irresponsable(X).

irresponsable(X) :- not( responsable(X) ).
Si el programa no ontiene el predi ado responsable nos en ontraremos on que
toda persona que ondu e es un piloto sui ida, lo que en la realidad no es ierto pero
188
bajo esta hiptesis s. La solu in ms orre ta sera evitar la nega in y denir el

predi ado
irresponsable.
9.3.6. Predi ado fail

Se utiliza para forzar el ba ktra king, dado que es un predi ado que siempre falla.
Se podra denir la nega in utilizando los predi ados ut y fail.
no(P) :- P, !, fail.
no(P).
9.4. Ejer i ios

1.
Modelo Rela ional

a ) Resolver el ejemplo del diseador de ropa usando SolveOne y SolveAll.
b ) Teniendo en uenta el ejemplo Deterministi Append, que su ede on la
llamada Append X [3 [1 2 3 la ual lgi amente debera devolver X=[1 2.
) Tradu ir a una frmula lgi a la siguiente versin de Append:
pro {Append A B ?C}

if B==C then A=nil
else
ase C of X|Cs then As in
A=X|As
{Append As B Cs}
end
end
end
d ) Utilizando el modelo rela ional es riba una versin de
Append
nodetermi-
nisti a (usar la senten ia hoi e ) que se omporte logi amente orre ta para
ualquier patron de inputs y outputs (help: todos los parmetros deben ser
de salida).
e ) Problema de las
posi iones de
nreinas.
Denir un predi ado que se satisfaga uando las
reinas en un tablero de ajedrez no se amenazan entre si.
La representa in del tablero se realiza mediante una lista de las alturas de
[4, 2, 7, 3, 6, 8, 5, 1] que indi a

(1, 4), (2, 2), (3, 7), (4, 3), . . .
ada reina. Una posible solu in sera:

reinas apare en en las oordenadas
2.
que las
PROLOG. Denir en Prolog los siguientes predi ados:

append[A, B, C]. Veri a si C es la
B a ontinua in de
lista obtenida on atenando los elemen-
b)
pertenece[L, L1]. L
L1.
elimina(X, Y S, ZS]. ZS
a)
tos de la lista
est en la lista
los elementos de la lista
es la lista resultante de eliminar
189
A.
de
Y S.
d)
inserta(X, Xs, Y s). Se umple

elemento X en la lista Xs.
e)
Interseccin, unin
f ) Problema de las
dif erencia
si la lista
Ys
es el resultado de insertar el
de onjunstos.
nreinas.
g ) Dar un ejemplo del problema de la nega in en Prolog.
190
Bibliografa
[1 Peter Van Roy and Seif Haridi. Con epts, Te hniques and Models of Computer
Programming. MIT Press, Cambridge, Massa husetts. ISBN: 0-262-22069-5. 2004.

[2 John C. Reynolds. Theories of Programming Languages. Cambridge University
Press. 1998. ISBN: 0-521-59414-6.
[3 David Watt. Programming Language Con epts and Paradigms. Prenti e Hall.
1990. ISBN: 0-13-728874-3.
[4 Terren e Pratt, Marvin Zelkowitz. Programming Languages, Design and Imple-
mentation (Third Edition). Prenti e Hall. 1996. ISBN: 0-13-678012-1.

[5 Ri hard Bird, Philip Wadler. Introdu tio to Fun tional Programming. Prenti e
Hall. 1988. ISBN: 0-13-484189-1.
[6 Noam Chomsky. Grammars.
R Ar hite ture Software Developer's Manual. Vol 1, 2, 3.

[7 IA-32 Intel
[8 Open C++. URL:
http://www.open ++.org.
191
ndi e de guras
1.1.
Una CFG y un rbol de deriva in. . . . . . . . . . . . . . . . . . . . . .
13
1.2.
Ejemplo de diagramas de sintaxis.
. . . . . . . . . . . . . . . . . . . . .
15
1.3.
Esquema de ompila in de un programa. . . . . . . . . . . . . . . . . .
17
2.1.
Ejemplo de la memoria onteniendo variables y valores.
. . . . . . . . .
24
2.2.
Programa de ejemplo en el lenguaje n leo de larativo. . . . . . . . . . .
26
2.3.
Identi adores y variables. . . . . . . . . . . . . . . . . . . . . . . . . . .
26
2.4.
Sintaxis del lenguaje n leo de larativo.
28
2.5.
Jerarqua de tipos bsi os. . . . . . . . . . . . . . . . . . . . . . . . . . .
29
2.6.
Operadores bsi os del lenguaje n leo de larativo. . . . . . . . . . . . .
32
. . . . . . . . . . . . . . . . . .
2.7.
Ejemplo de estru turas li as. . . . . . . . . . . . . . . . . . . . . . . .
40
2.8.
El algoritmo de uni a in.
. . . . . . . . . . . . . . . . . . . . . . . . .
41
5.1.
Ejemplo de un programa C
. . . . . . . . . . . . . . . . . . . . . . . . .
5.2.
Algunas dire tivas del pre-pro esador.
. . . . . . . . . . . . . . . . . . .
87
89
5.3.
Tipos de datos bsi os . . . . . . . . . . . . . . . . . . . . . . . . . . . .
90
5.4.
Ejemplo de de lara iones lo ales y globales
94
5.5.
Representa in en memoria de un ve tor (en el sta k). . . . . . . . . . . 105
. . . . . . . . . . . . . . . .
6.1.
Representa in en memoria de un pro eso. . . . . . . . . . . . . . . . . . 112
6.2.
Manejo de la memoria estti a en FORTRAN 77. . . . . . . . . . . . . . 113
6.3.
Formato de un registro de a tiva in. . . . . . . . . . . . . . . . . . . . . 115
6.4.
Implementa in de stati s ope on un display.
6.5.
Crea in y manejo de valores dinmi os. . . . . . . . . . . . . . . . . . . 118
. . . . . . . . . . . . . . 117
6.6.
Estru turas de datos del heap.
. . . . . . . . . . . . . . . . . . . . . . . 119
7.1.
Implementa in de un objeto Counter
7.2.
Una posible implementa in de una lase.
. . . . . . . . . . . . . . . . . . . 123
7.3.
Sintaxis extendida para soportar OOP. . . . . . . . . . . . . . . . . . . . 125
. . . . . . . . . . . . . . . . . 124
7.4.
Ejemplo de una lase.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
7.5.
Ejemplo de una lase.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
7.6.
Ejemplo de uso de tablas virtuales
7.7.
Problema del rombo on heren ia mltiple . . . . . . . . . . . . . . . . . 138
. . . . . . . . . . . . . . . . . . . . . 132
7.8.
Ejemplo de un programa Java.
. . . . . . . . . . . . . . . . . . . . . . . 141
192
NDICE DE FIGURAS
7.9.
NDICE DE FIGURAS
Ejemplos de plantillas (templates) en C++. . . . . . . . . . . . . . . . . 143
7.10. Ejemplos de uso de la STL.
. . . . . . . . . . . . . . . . . . . . . . . . . 144
8.1.
Orden ausal e inter ala in (interleaving) . . . . . . . . . . . . . . . . . 151
8.2.
Pro esos o tareas y threads
8.3.
Algunas opera iones sobre threads. . . . . . . . . . . . . . . . . . . . . . 154
8.4.
Ejemplo de una barrera (rendezvous).
8.5.
Ejemplo una ondi in de arrera.
. . . . . . . . . . . . . . . . . . . . . 159
8.6.
Ejemplo una ondi in de arrera.
. . . . . . . . . . . . . . . . . . . . . 159
8.7.
Ejemplo de produ tor- onsumidor on mensajes y puertos. . . . . . . . . 162
8.8.
Ejemplo de un programa on un poten ial deadlo k.
9.1.
rbol de Bsqueda para el ejemplo del diseador de ropa. . . . . . . . . 172
. . . . . . . . . . . . . . . . . . . . . . . . . 153
. . . . . . . . . . . . . . . . . . . 154
. . . . . . . . . . . 164
9.2.
Tradu in de un Programa Rela ional a Frmula Lgi a. . . . . . . . . 175
9.3.
Estrategia de Resolu in SLD.
9.4.
Re orrido en el espa io de bsqueda. . . . . . . . . . . . . . . . . . . . . 187
9.5.
Re orrido en el espa io de bsqueda on Ba ktra king. . . . . . . . . . . 188
. . . . . . . . . . . . . . . . . . . . . . . 186
193
ndi e de uadros
194
ndi e de algoritmos
195

Acl Book

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Acl Book

Transféré par

Droits d'auteur :

Formats disponibles

Lenguajes de programa

Mar elo Daniel Arroyo

imperativo, fun ional, orientado

Este ltimo modelo es transversal a los dems

Oz, el ual es un lenguaje a admi o desarrollado

espe  amente para el estudio de los diferentes modelos de omputa in.

Lenguajes omo herramientas de programa in

Abstra in pro edural

Evalua in de un lenguaje de programa in . . . . . . . . . . . . . . . .

Deni in de un lenguaje de programa in . . . . . . . . . . . . . . . . .

EBNFs y diagramas de sintaxis . . . . . . . . . . . . . .

Herramientas para la onstru in de programas

Bibliote as estti as y dinmi as . . . . . . . . . . . . . . . . . .

Identi adores de variables

Valores par iales, estru turas li as y aliasing . . . . . . . . . .

Sintaxis del lenguaje n leo de larativo

Valores y tipos de datos . . . . . . . . . . . . . . . . . . . . . . .

Porqu registros y pro edimientos?

Adornos sint ti os y abstra iones lingusti as . . . . . . . . . .

Opera iones bsi as del lenguaje

Opera iones sobre ambientes

Semnti a de las senten ias . . . . . . . . . . . . . . . . . . . . .

Tipado estti o vs dinmi o . . . . . . . . . . . . . . . . . . . . .

Uni a in (operador '=') . . . . . . . . . . . . . . . . . . . . . .

2.3.10. Igualdad (operador

3. lenguajes fun ionales

Programa in fun ional

Cara tersti as prin ipales . . . . . . . . . . . . . . . . . . . . . . . . . .

Ventajas y desventajas on respe to a la programa in imperativa

Computa in y l ulo lambda . . . . . . . . . . . . . .

Lenguajes fun ionales modernos . . . . . . . . . . . . . . . . . . . . . . .

Tipos de datos estru turados . . . . . . . . . . . . . . .

Referen ias (variables) . . . . . . . . . . . . . . . . . . .

Otras ara tersti as imperativas . . . . . . . . . . . . .

Evalua in perezosa y sus onse uen ias . . . . . . . . .

Clases y sobre arga de operadores . . . . . . . . . . . .

4. El modelo on estado (statefull)

Constru in de sistemas on estado

Programa in basada en omponentes . . . . . . . . . . . . . . .

Abstra in pro edural . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5. Lenguajes de programa in imperativos

Estru tura de un programa C . . . . . . . . . . . . . . . . . . . . . . . .

Tipos de datos bsi os . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.10. De lara iones y deni iones . . . . . . . . . . . . . . . . . . . . . . . . .

5.11. Deni iones de variables . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.12. Deni iones de onstantes . . . . . . . . . . . . . . . . . . . . . . . . . .

5.13. Deni iones de tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.14. Fun iones

5.15. Al an e de las de lara iones . . . . . . . . . . . . . . . . . . . . . . . . .

5.16. Tiempo de vida de las entidades

5.16.1. Cambiando el tiempo de vida de variables lo ales . . . . . . . . .

5.17.2. Expresiones ondi ionales

5.17.3. Otras expresiones . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.18.2. Senten ias ondi ionales . . . . . . . . . . . . . . . . . . . . . . .

5.18.3. Senten ias de itera in . . . . . . . . . . . . . . . . . . . . . . . .

5.18.3.1. Itera in denida

5.19.1. Arreglos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

5.20.2. Punteros a fun iones . . . . . . . . . . . . . . . . . . . . . . . . . 107

Manejo de la memoria e iente

Manejo del sta k

Implementa in del manejo de al an e de ambientes. . . . . . . . 116

Valores reados dinmi amente. Manejo del heap. . . . . . . . . . . . . . 118

Manejo del heap

espe amente para el estudio de los diferentes modelos de omputa in.

Deni in de un lenguaje de programa in . . . . . . . . . . . . . . . . .

Identi adores de variables

Uni a in (operador '=') . . . . . . . . . . . . . . . . . . . . . .

5.10. De lara iones y deni iones . . . . . . . . . . . . . . . . . . . . . . . . .

5.11. Deni iones de variables . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.12. Deni iones de onstantes . . . . . . . . . . . . . . . . . . . . . . . . . .

5.13. Deni iones de tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.18.3.1. Itera in denida

Manejo de la memoria e iente

Plani a in de threads (s heduling) . . . . . . . . . . . . . . . . . . . . 152

Uni a in y Regla de Resolu in

de mquina en forma simbli a y la deni in de ma ros, hasta llegar a los lenguajes

La programa in es la a tividad que onsiste en denir y usar abs-

1.4. Deni in de un lenguaje de programa in

programas re ono edores de lenguajes (parsers y lexers) a partir de su espe i a in .

VN es el onjunto nito de smbolos no terminales,

onjunto nito de produ iones.