Calculo Lambda Tipado (2/3)

Departamento de Computaci
on, FCEyN, UBA

25 de agosto de 2016
Mas extensiones

I Registros
I Declaraciones locales
I Referencias
Programacion Imperativa = Progr. Funcional + Efectos
I Recursion
I Ninguna de las extensiones vistas permite definir funciones
recursivas.
I Todas las funciones definibles hasta el momento son totales.
Tipos y terminos de ...r

Sea L un conjunto de etiquetas

::= . . . | {li : i i1..n }

I {nombre : String , edad : Nat}

I {persona : {nombre : String , edad : Nat}, cuil : Nat}

{nombre : String , edad : Nat} =

6 {edad : Nat, nombre : String }
Tipos y terminos de ...r

M ::= . . . | {li = Mi i1..n } | M.l

Descripcion informal:
I El registro {li = Mi i1..n } eval
ua a {li = Vi i1..n } donde Vi
ua Mi , i 1..n
es el valor al que eval
I M.l: evaluar M hasta que arroje {li = Vi i1..n }, luego
proyectar el campo correspondiente
Ejemplos

I x : Nat.y : Bool.{edad = x, esMujer = y }

I p : {edad : Nat, esMujer : Bool}.p.edad
I (p : {edad : Nat, esMujer : Bool}.p.edad)
{edad = 20, esMujer = false}
Tipado de ...r

 Mi : i para cada i 1..n

(T-Rcd)
 {li = Mi i1..n
} : {li : i i1..n
}

 M : {li : i i1..n
} j 1..n
(T-Proj)
 M.lj : j
Semantica operacional de ...r

Valores

V ::= . . . | {li = Vi i1..n }

Semantica operacional de ...r

j 1..n
(E-ProjRcd)
i1..n
{li = Vi }.lj Vj

M M0
(E-Proj)
M.l M 0 .l

Mj Mj0
(E-Rcd)
i1..j1 ij+1..n
{li = Vi , lj = Mj , li = Mi }

{li = Vi i1..j1 , lj = Mj0 , li = Mi ij+1..n
}
Tipos y terminos de ...let

M ::= . . . | let x : = M in N

Descripcion informal:
I let x : = M in N: evaluar M a un valor V , ligar x a V y
evaluar N
I Mejora la legibilidad
I La extension con let no implica agregar nuevos tipos
Ejemplo

I let x : Nat = 2 in succ(x)

I pred (let x : Nat = 2 in x)
I let x : Nat = 2 in let x : Nat = 3 in x
Tipado de ...let

 M : 1 , x : 1  N : 2
(T-Let)
 let x : 1 = M in N : 2
Semantica operacional de ...let

M1 M10
(E-Let)
let x : = M1 in M2 let x : = M10 in M2

(E-LetV)
let x : = V1 in M2 M2 {x V1 }
Referencias - Motivacion

I En una expresion como let x : Nat = 2 in M

I x es una variable declarada con valor 2.
I El valor de x permanece inalterado a lo largo de la evaluacion
de M.
I En este sentido x es inmutable: no existe una operacion de
asignaci
on.
I En programacion imperativa pasa todo lo contrario.
I Todas las variables son mutables.
I Vamos a extender Calculo Lambda Tipado con variables
mutables.
Operaciones basicas

Alocacion (Reserva de memoria)

ref M genera una referencia fresca cuyo contenido es el valor de
M.

Derreferenciacion (Lectura)
!x sigue la referencia x y retorna su contenido.

Asignacion
x := M almacena en la referencia x el valor de M.
Comandos = Expresiones con efectos

I El termino let x = ref 2 in x := succ(!x), A que eval

ua?
I La asignacion es una expresi
on que interesa por su efecto y no
su valor.
I Carece de sentido preguntarse por el valor de una asignacion.
I S tiene sentido preguntarse por el efecto!

Comando
Expresion que se eval
ua para causar un efecto; lo expresamos con
un nuevo valor unit.
I Un lenguaje funcional puro es uno en el que las expresiones
son puras en el sentido de carecer de efectos.
Tipos y terminos de bnu

::= Bool | Nat | Unit |

M ::= . . . | unit

Descripcion informal:
I Unit es un tipo unitario y el u
nico valor posible de una
expresion de ese tipo es unit.
I Cumple rol similar a void en C o Java
Tipado de bnu

Agregamos el axioma de tipado:

(T-Unit)
 unit : Unit

NB:
I No hay reglas de evaluaci
on nuevas
I Extendemos el conjunto de valores V con unit
V ::= . . . | unit
Utilidad

I Su utilidad principal es en lenguajes con efectos laterales

I En estos lenguajes es u
til poder evaluar varias expresiones en
secuencia

def
M1 ; M2 = (x : Unit.M2 ) M1 x
/ FV (M2 )

I La evaluaci
on de M1 ; M2 consiste en primero evaluar M1 y
luego M2
I Con la definici
on dada, este comportamiento se logra con las
reglas de evaluaci
on definidas previamente
Expresiones de tipos

Las expresiones de tipos se extienden del siguiente modo

::= Bool | Nat | | Unit | Ref

Descripcion informal:
I Ref es el tipo de las referencias a valores de tipo .
I Ej. Ref (Bool Nat) es el tipo de las referencias a funciones
de Bool en Nat.
Terminos

M ::= x
| x : .M
| MN
| unit
| ref M
| !M
| M := N
| ...

El sistema de tipado excluira terminos mal formados.

I !2
I 2 := 3
Reglas de tipado - Preliminares

 M1 :
(T-Ref)
 ref M1 : Ref

 M1 : Ref
(T-DeRef)
!M1 :

 M1 : Ref 1  M2 : 1
(T-Assign)
 M1 := M2 : Unit
Ejemplos

I let x = ref 2 in ( : unit.!x) (x := succ(!x))

I let x = ref 2 in x
I let x = 2 in x
I let x = ref 2 in let y = x in ( : unit.!x) (y := succ(!y ))

Nota: el tem del primer punto puede escribirse tambien:

let x = ref 2 in (x := succ(!x)); !x

Recordemos que:
def
M1 ; M2 = (x : Unit.M2 ) M1 x
/ FV (M2 )
Motivacion

Al intentar formalizar la semantica operacional surgen las

preguntas:
I Cuales son los valores de tipo Ref ?
I Como modelar la evaluaci
on del termino ref M?
Las respuestas dependen de otra pregunta.

Que es una referencia?

Rta. Es una abstracci

on de una porci
on de memoria que se
encuentra en uso.
Memoria o store

I Usamos direcciones (simbolicas) o locations l, li L para

representar referencias.
Memoria (o store): funci
on parcial de direcciones a valores.
I Usamos letras , 0 para referirnos a stores.
I Notacion:
I [l 7 V ] es el store resultante de pisar (l) con V .
I (l 7 V ) es el store extendido resultante de ampliar con
una nueva asociaci on l 7 V (asumimos l / Dom()).
Los juicios de evaluaci
on toman la forma:

M | M 0 | 0
Valores

Intuicion:
l
/ Dom()
(E-RefV)
ref V | l | (l 7 V )
Los valores posibles ahora incluyen las direcciones.

V ::= unit | x : .M | l

Dado que los valores son un subconjunto de los terminos,

I debemos ampliar los terminos con direcciones;
I estas son producto de la formalizaci
on y no se pretende que
sean utilizadas por el programador.
Terminos extendidos

M ::= x
| x : .M
| MN
| unit
| ref M
| !M
| M := N
| l
| ...
Juicios de tipado

l :?

I Depende de los valores que se almacenen en la direccion l.

I Situacion parecida a las variables libres.
I Precisamos un contexto de tipado para direcciones:
I funci
on parcial de direcciones en tipos.

Nuevo juicio de tipado

|  M :
Reglas de tipado - Definitivas

|  M1 :
(T-Ref)
|  ref M1 : Ref

|  M1 : Ref
(T-DeRef)
|!M1 :

|  M1 : Ref 1 |  M2 : 1
(T-Assign)
|  M1 := M2 : Unit

(l) =
(T-Loc)
|  l : Ref
Juicios de evaluacion en un paso

I Retomamos la semantica operacional.

I Vamos a introducir axiomas y reglas que permiten darle
significado al juicio de evaluaci
on en un paso.

M | M 0 | 0

I Recordar el conjunto de valores (expresiones resultantes de

evaluar por completo a terminos cerrados y bien tipados).

V ::= true | false | 0 | n | unit | x : .M | l

Juicios de evaluacion en un paso (1/4)

M1 | M10 | 0
(E-App1)
M1 M2 | M10 M2 | 0

M2 | M20 | 0
(E-App2)
V1 M2 | V1 M20 | 0

(E-AppAbs)
(x : .M) V | M{x V } |

Nota: Estas reglas no modifican el store.

Juicios de evaluacion en un paso (2/4)

M1 | M10 | 0
(E-Deref)
!M1 | !M10 | 0

(l) = V
(E-DerefLoc)
!l | V |
Juicios de evaluacion en un paso (3/4)

M1 | M10 | 0
(E-Assign1)
M1 := M2 | M10 := M2 | 0

M2 | M20 | 0
(E-Assign2)
V := M2 | V := M20 | 0

(E-Assign)
l := V | unit | [l 7 V ]
Juicios de evaluacion en un paso (4/4)

M1 | M10 | 0
(E-Ref)
ref M1 | ref M10 | 0

l
/ Dom()
(E-RefV)
ref V | l | (l 7 V )
Ejemplo

let x = ref 2 in ( : Unit.!x) (x := succ(!x)) |

let x = l1 in ( : Unit.!x) (x := succ(!x)) | (l1 7 2)
( : Unit.!l1 ) (l1 := succ(!l1 )) | (l1 7 2)
( : Unit.!l1 ) (l1 := succ(2)) | (l1 7 2)
( : Unit.!l1 ) unit | ( (l1 7 2))[l1 7 3]
!l1 | (l1 7 3)
3 | (l1 7 3)
Ejemplo
Sea
M = r : Ref (Unit Unit).
let f =!r
in (r := x : Unit.f x); (!r ) unit

M (ref (x : Unit.x)) |
M l1 | (l1 7 x : Unit.x)
let f =!l1 in (l1 := x : Unit.f x); (!l1 ) unit | ...
let f = x : Unit.x in (l1 := x : Unit.f x); (!l1 ) unit | ...
(l1 := x : Unit.(x : Unit.x) x); (!l1 ) unit | ...
unit; (!l1 ) unit | (l1 7 x : Unit.(x : Unit.x) x)
(!l1 ) unit | (l1 7 x : Unit.(x : Unit.x) x)
(x : Unit.(x : Unit.x) x) unit | ...
(x : Unit.x) unit | ...
unit | ...
Ejemplo

Sea
M = r : Ref (Unit Unit).
let f =!r
in (r := x : Unit.f x); (!r ) unit
Reemplazamos f por !r y nos queda
M 0 = r : Ref (Unit Unit).
(r := x : Unit.(!r ) x); (!r ) unit

Vamos a evaluar este nuevo M 0 aplicado al mismo termino que en

el slide anterior y ver que pasa...
Ejemplo

M 0 = r : Ref (Unit Unit).

(r := x : Unit.(!r ) x); (!r ) unit

M 0 (ref (x : Unit.x)) |
M 0 l1 | (l1 7 x : Unit.x)
(l1 := x : Unit.(!l1 ) x); (!l1 ) unit | ...
unit; (!l1 ) unit | (l1 7 x : Unit.(!l1 ) x)
(!l1 ) unit | ...
(x : Unit.(!l1 ) x) unit | ...
(!l1 ) unit | ...
...

Nota: no todo termino cerrado y bien tipado termina en bnr

(-calculo con booleanos, naturales y referencias).
La clase pasada - Correccion de sistema de tipos

Correcci
on = Progreso + Preservacion

Progreso
Si M es cerrado y bien tipado entonces
1. M es un valor
2. o bien existe M 0 tal que M M 0

Preservacion
Si  M : y M N, entonces  N :
Debemos reformular estos resultados en el marco de referencias.
Preservacion - Formulacion ingenua

La formulacion ingenua siguiente es err

onea:

|  M : y M | M 0 | 0 implica |  M 0 :

I El problema: puede que la semantica no respete los tipos

asumidos por el sistema de tipos para las direcciones (i.e. ).
I Vamos a ver un ejemplo concreto.
Preservacion - Formulacion ingenua

|  M : y M | M 0 | 0 implica |  M 0 :

Supongamos que
I M =!l
I =
I (l) = Nat
I (l) = true
Observar que
I |  M : Nat y
I M | true |
I pero |  true : Nat no vale.
Preservacion - Formulacion ingenua

Formulacion ingenua

|  M : y M | M 0 | 0 implica |  M 0 :

Supongamos que
I M =!l
I =
I (l) = Nat
I (l) = true
Observar que
I |  M : Nat y
I M | true |
I pero |  true : Nat no vale.
Preservacion - Reformulada

I Precisamos una nocion de compatibilidad entre el store y el

contexto de tipado para stores.
I Debemos tipar los stores.
I Introducimos un nuevo juicio de tipado:
| 
I Este juicio se define del siguiente modo:
|  sii
1. Dom() = Dom() y
2. |  (l) : (l) para todo l Dom().
Preservacion - Reformulada

Reformulamos preservaci
on del siguiente modo.

Si |  M : y M | N | 0 y |  ,

entonces |  N : .

I Esto es casi correcto.

I No contempla la posibilidad de que el encuadrado haya
crecido en dominio respecto a .
I Por posibles reservas de memoria.
Preservacion - Definitiva

Si
I |  M :
I M | N | 0
I | 
implica que existe 0 tal que
I |0  N :
I |0  0
Progreso - Reformulado

Si M es cerrado y bien tipado (i.e. |  M : para alg

un , )
entonces:
1. M es un valor
2. o bien para cualquier store tal que |  , existe M 0 y 0
tal que M | M 0 |0 .
Recursion

Ecuacion recursiva

f = ...f ...f ...

Dos explicaciones de la funci

on denotada (cuando existe).
I Denotacional
I Lmite de una cadena de aproximaciones
I Operacional
I El desdoblador y puntos fijos
Terminos y tipado

M ::= . . . | fix M

I No se precisan nuevos tipos pero s una regla de tipado.

 M : 1 1
(T-Fix)
 fix M : 1
Semantica operacional small-step

No hay valores nuevos pero s reglas de evaluaci

on en un paso
nuevas.

M1 M10
(E-Fix)
fix M1 fix M10

(E-FixBeta)
fix (x : .M) M{x fix (x : .M)}
Ejemplos

Sea M el termino
f : Nat Nat.
x : Nat.
if iszero(x) then 1 else x f (pred(x))
en

let fact = fix M in fact 3

Ejemplos

fix (x : Nat.x + 1)
Ejemplos

Sea M el termino
s : Nat Nat Nat.
x : Nat.
y : Nat.
if iszero(x) then y else succ(s pred(x) y )
en

let suma = fix M in suma 2 3

Letrec

Una construccion alternativa para definir funciones recursivas es

letrec f : = x : .M in N

Por ejemplo,
letrec
fact : Nat Nat =
x : Nat.if x = 0 then 1 else x fact(pred(x))
in fact 3
letrec puede escribirse en terminos de fix del siguiente modo:

let f = fix (f : .x : .M) in N

Fin de la clase

La clase que viene...

...inferencia de tipos.