Teoría de Lenguajes

Teoría de la Programación
Clase 2: Introducción parte 2 - Modelo Declarativo
 Oz - Procedimientos

Los procedimientos son conceptos más básicos que las

funciones.

Se utilizan variables no ligadas como parámetros

Oz - Pattern Matching

Es una manera de acceder a los campos de una estructura

de datos y obtener los valores

Un patrón “matchea” sobre un record cuando coincide:

Width, Label & Features
Ejemplo: Length de una lista
 1) Devolver el máximo de una lista
Ejercicios! de enteros

2) A partir de una lista de números

devolver una lista de los valores
absolutos
 Oz - Evaluación perezosa (Lazy)

Eager vs Lazy

En la evaluación perezosa los cálculos se hacen recién al

momento en que se necesitan

fun lazy {Ints N}

N|{Ints N+1}
end
 Oz - Alto orden (high order programming)

Funciones como ciudadanos de primera clase (first class)

Poder pasar funciones como parámetro a otras funciones se

conoce como programación de alto orden
 Oz - Concurrencia

Threads

Comunicación entre threads

local A B C in
thread A = B + C end
C = 4
thread B = 10 end
{Browse A}
end
 Oz - Dataflow

¿Qué pasa si queremos usar una variable que todavía no

está ligada a un valor?

● ¿Se lanza un error?

● ¿Se asume un valor por defecto?
● ¿Se detiene la ejecución?
 Oz - Estado explícito

Explícito vs Implícito

Utilización de estados con celdas de memoria:

● NewCell
● @
● :=
C={NewCell 0} C:=@C+1 {Browse @C}
 Oz - Objetos

¿Con los conceptos que vimos hasta ahora, cómo definirían

un objeto como lo conocen?

Al objeto lo vamos a definir por ahora como una función con

memoria interna
 Oz - Clases

¿Cómo hacemos para tener más de una instancia de un

objeto?

Definimos a la clase como una fábrica de objetos. Permite

crear instancias.
Oz - Indeterminismo y atomicidad

Concurrencia + estados
=
Indeterminismos

Atomicidad de operaciones con Locks

 PARTE 2
MODELO COMPUTACIONAL
Modelo computacional

Sistema formal que define cómo se ejecutan los cálculos. Se define en

términos de los conceptos que incluye. Sintaxis y semántica

Un modelo computacional es una definición más precisa de un paradigma

de programación.
¿Qué nos permite estudiar un
modelo computacional?
Modelo computacional

● Correctitud
● Complejidad temporal
● Complejidad espacial
Modelo declarativo
Modelo declarativo

● Evaluar funciones sobre estructuras de datos(parciales)

○ Sin estado (Stateless)
○ Paralelizable
○ Deterministico
○ Sin efectos secundarios
○ Fácil de probar

● Ideas principales del paradigma funcional y lógico

Modelo declarativo

Edsger Dijkstra (1930-2002)

“Object-oriented programming is an
exceptionally bad idea which could only
have originated in California”
Modelo declarativo

Alan Kay (1940)

Entre otras cosas, creador de Smalltalk

“You probably know that arrogance, in

computer science, is measured in
nanodijkstras”
Modelo declarativo

Una torta es 45 minutos de 200°C de calor aplicado a 200 mg de masa de torta

final.
100 mg de masa de torta final es una mezcla de 99 mg de masa de torta etapa
2 y 1 mg de sal.
99 mg de masa de torta etapa 2 es una mezcla de 79 mg de harina y un huevo.
¿Cómo definimos un
lenguaje?
 caracteres tokens Syntax
tree
Sintaxis Tokenizer Parser

Qué es legal en un
programa sin importar
qué es lo que el
programa esté
haciendo
Sintaxis - EBNF

Extended Backus-Naur Form

<digit> ::== 0|1|2|3|4|5|6|7|8|9

<int> ::== <digit>{<digit>}
Semántica

Qué es lo que hace el programa al ejecutarse

Debe:

○ Ser simple
○ Permitir entender el programa en cuanto a
correctitud y complejidad
 Semántica - Kernel Language approach

● Set mínimo de instrucciones intuitivas

● Fácil de razonar, con semántica formal

● Se extiende a un lenguaje práctico a través de

○ Syntactic sugar
○ Linguistic abstraction
Lenguaje Kernel
Lenguaje Kernel - Valores
Lenguaje Kernel - Statements
Expressions vs Statements

Una expresión es un valor. Es el resultado de

una operación. Es algo que puede ser asignado
a una variable

Un statement es una secuencia de operaciones

que no devuelven valor
Múltiples declaraciones

local A B in local A in
A = 4 local B in
B = 5 + A A = 4
end B = 5 + A
end
end
Declaraciones sin asignación

local X=<expression> local X in

in X = <expression>
<statement> <statement>
end end
Funciones a procedimientos

X = {F Y} {F Y X}
Llamados anidados

{P {F A X} Y} local U in
{F A X U}
{P U Y}
end
Condicionales booleanos

if X > Y then local B in

<statement> B = X > Y
end if B then
<statement>
end
end
Ejemplo

Length
Scoping y procedures
Scoping - local scoping

local X in
X=1
local X in
X=2
{Browse X} % Muestra 2
end
{Browse X} % Muestra 1
end
Scoping - static vs dynamic scoping

local P Q in
proc {Q X} {Browse stat(X) end
proc {P X} {Q X} end
local Q in
proc {Q X} {Browse dyn(X)} end
{P ‘hola’}
end
end
Scoping - static vs dynamic scoping

local P Q in
proc {Q X} {Browse stat(X) end
proc {P X} {Q X} end
local Q in
proc {Q X} {Browse dyn(X)} end
{P ‘hola’}
end
end
Abstraccion procedural

Cualquier statement puede convertirse en un

procedimiento

En un statement un identificador es libre si no

está definido en el mismo
Máquina abstracta
Single Assignment
Store ● Variables declarativas
● Value store
● Partial values

𝛔 ●

Ej:
Variables dataflow

𝛔 = {x1=100, x2=[1 2 3],x3}

Entorno ● Identificadores

Notación:

E
<x> identificador de una variable
E(<x>) el valor en el store del
identificador <x> según su entorno

Operaciones:
Adición: E’ = E + {<x>-> x}
Restricción: E’ = E|{<x>,..<z>}
STACK ● Pila de semantic
statements

ST Semantic statement es un
par (<s>,E) siendo <s> un
statement
Cómputo

● Estado de ejecución.
● Un cómputo define cómo se modifica el estado de
ejecución de un programa.
Estados de ejecución

● Ejecutable

● Terminado

● Suspendido
Semántica
Statements
Skip

En el tope del ST tenemos el siguiente semantic statement (skip, E)

Se continua con el próximo paso

(skip, E) 𝛔 ST 𝛔
+ +
ST {...} {...}
 Composición secuencial
En el tope del ST tenemos el siguiente semantic statement (<s1> <s2>, E)

Se apila cada statement en el ST con el mismo entorno de la composición

(<s1>, E)
(<s1> <s2>, E) 𝛔 𝛔
+ (<s2>, E) +
ST {...} {...}
ST
 Declaración de variable
En el tope del ST tenemos el siguiente semantic statement
(local <x> in <s> end , E)
● Se crea la variable x en el store

● Se crea un ambiente E’ = E + {<x> -> x}. Es decir un ambiente igual al

anterior pero con el identificador <x> mapeando a la variable recién creada

● Se apila (<s>,E’) al ST

● Se continua con la próxima ejecución

Declaración de variable

(local A in <s> end, E) 𝛔

+
ST {...}

(<s>, E’) 𝛔 ● E’ = E + {A->a1}

+ ● a1 no ligada en 𝛔
ST {..., a1}
 Igualdad variable - variable
En el tope del ST tenemos el siguiente semantic statement (<x1> = <x2>, E)

Se hace un bind de E(<x1>) con E(<x2>) en el store

(<x1> = <x2>, E) 𝛔 ST 𝛔
+ {x1,x2,...} + {x =x ...}
ST 1 2
 Igualdad variable - valor
En el tope del ST tenemos el siguiente semantic statement (<x> = <v>, E)

<v> es un record, un numero o un procedimiento

Se crea el valor y se liga a la variable <x> en el store

(<x> = <v>, E) 𝛔 ST 𝛔
+ {x,...} + {x=v...}
ST
EJEMPLO

local X Y Z in
X = 10
Y = 40
Z = X
local X A in
X = 30
A = persona(nombre:'Lean' edad:X)
end
end
 Bibliografía
● Concepts, Techniques, and Models of Computer Programming - Capítulo 2, Peter Van Roy and
Seif Haridi
● Extras:
○ A practical introduction to functional programming (with Python)

https://maryrosecook.com/blog/post/a-practical-introduction-to-functional-programming

○ Abstract syntax tree https://en.wikipedia.org/wiki/Abstract_syntax_tree