Document

Subtipado (2)
Paradigmas de lenguajes de
programación
1er cuatrimestre 2007
Metateoría de subtipado
Eliminación de reglas (S-Ref, S-Trans,
T-Sub)
Algoritmos de tipado/subtipado
Tipado minimal
Join & Meet
Tipado mínimo
Sintaxis
T ::=
Top
tope
|T→T
funciones
| {li : Ti, i ∈ 1..n}
registros
No agregamos nada más por ahora
Reglas de subtipado
S <: S
(S-Refl)
S <: U
U <: T
 (S-Trans)
S <: T
S <: Top
(S-Top)
Reglas de tipado
A<:A’
B <: B’

A’ → B <: A → B’
(S-Arrow)
{li, i ∈ 1..n} ⊆ {kj, j ∈ 1..m}
kj = li ⇒ Sj <: Ti
 (S-Rcd)
{kj : Sj, j ∈ 1..m} <: {li : Ti, i ∈ 1..n}
Regla S-Rcd
Lema
S<:T es derivable con
S-RcdDepth, S-RcdWidth,
S-RcdPerm
⇔
es derivable sólo con S-Rcd
Dem.
Inducción en la derivación
Eliminación de S-Ref
Por qué es superflua S-Ref
Derivación dirigida por sintaxis
Lema
S<:T es derivable
⇔
es derivable sin usar S-Ref
Dem.
(⇒) Inducción en la derivación
Eliminación de S-Trans
Por qué es superflua S-Trans
Derivación dirigida por sintaxis
Lema
S<:T es derivable
⇔
es derivable sin usar S-Trans (ni S-Ref)
Dem.
(⇒) Inducción en la derivación, usando el lema
anterior
Agregado cultural
Suponer que agregamos el tipo base
Bool (u otro) . ¿Cómo se modifica lo
anterior?
Solución
Necesaria S-Ref para Bool <: Bool
O bien especificar los pares que cumplan
Subtipado algorítmico
(S-Top)
S <: Top
A<:A’
B <: B’

A’ → B <: A → B’
(S-Arrow)
{li, i ∈ 1..n} ⊆ {kj, j ∈ 1..m}
kj = li ⇒ Sj <: Ti
 (S-Rcd)
{kj : Sj, j ∈ 1..m} <: {li : Ti, i ∈ 1..n}
Notación:
|→
→ S <: T
Reformulación
Proposición (correctitud y completitud)
S <: T
⇔
|→ S <: T
Dem.
Inducción en la derivación, usando los
dos lemas anteriores
Algoritmo de subtipado
subtype(S,T) =
if T = Top then true
else
if S = S1 → S2 and T = T1 → T2 then
subtype(T1,S1) and subtype(S2,T2)
else
if S = {kj : Sj, j ∈ 1..m} and T = {li : Ti, i ∈ 1..n}
then {li, i ∈ 1..n} ⊆ {kj, j ∈ 1..m} and
∀i ∃j kj=li and subtype(Sj,Ti)
else false
Correctitud y completitud del
algoritmo
Proposición
Si |→ S <: T, el algoritmo anterior
devuelve true.
Si no, el algoritmo anterior devuelve
false.
Además, el algoritmo anterior siempre
termina.
Tipado algorítmico
Se busca el tipo mínimo
Se calculará bottom up
Γ | t : S
S <: T

Γ | t : T
(T-Sub)
No es dirigida por sintaxis,
siempre podría aplicarse
Puede posponerse la T-Sub
Reglas de tipado algorítmico
(1)
x:T ∈ Γ
 (TA-Var)
Γ |→ x:T
Γ |→ t1 : T → T’
Γ |→ t2 : S |→ S <: T
 (TA-App)
Γ |→ t1 t2 : T’
Γ , x : T |→ t : T’
 (TA-Abs)
Γ |→ λ x:T. t : T → T’
Typechecking: interpretar premisa 1 de TA-App como Γ |→ t1: A y
chequear que A tenga la forma T → T’
Reglas de tipado algorítmico
(2)
∀i Γ |→ ti : Ti
 (TA-Rcd)
Γ |→ {li=ti, j ∈ 1..n} : {li : Ti, i ∈ 1..n}
∀i Γ |→ t : {li : Ti, i ∈ 1..n}
 (TA-Proj)
Γ |→ t . lj : Tj
Propiedad
Teorema (correctitud)
Γ |→ t : T
⇒
Γ | t : T
Dem.
Inducción en la derivación
(derecho viejo)
Propiedad de tipado mínimo
Teorema (sub completitud o tipado
mínimo)
Γ | t : T
⇒
Γ |→ t : S
para algún S <: T
Dem.
Inducción en la derivación
Y por la correctitud, claramente el tipo S
es mínimo
Join & Meet: motivación
Regla clásica
Γ | b : Bool Γ | t2 : T Γ | t3 : T

Γ | if b then t2 else t3 : T
Pero qué tipo debería tener la expresión
if true then {x=1,y=2} else {x=3,z=4}
Acotación
Podemos usar un tipo que acote a ambos
{x:Int,y:Int} y {x:Int,z:Int}
A priori hay varias posibilidades:
{x:Int}
{x:Float}
{x:Top}
{}
Top
¿cuál elegimos?
El encuentro …
Join de S y T
S ∨ T es un mínimo tipo A tal que
S<:A , T<:A
Meet de S y T
S ∧ T es un máximo tipo A tal que
A<:S , A<:T
Vista en conjunto
S∨T
S
T
S∧T
Equivalencia
Definición: para tipos A y B
A = B ⇔ A <: B <: A
“A equivalente a B”
En otras palabras, son deducibles ambas
relaciones.
La relación = resulta una relación de
equivalencia.
Primera junta
Existencia de join
siempre
¿Existencia de meet?
no siempre
Existencia de bounded meet
siempre
¿Unicidad de join y meet?
no siempre
Unicidad módulo equivalencia
siempre
Condicional re acondicionado
Regla nueva
Γ | b : Bool
Γ | t2 : T2 Γ | t3 : T3

Γ | if b then t2 else t3 : (T2 ∨ T3)
El del ejemplo anterior será:
| if true then {x=1,y=2} else {x=3,z=4} : {x:Int}
Ejercicio mínimo
Encontrar el tipo mínimo de
if true then { x:2 , y:3 } else { x:4 , y:5 }
if false then { x:2 , y:3 } else { x:1 }
if true then { x:2 } else { y:3 }
if false the false else { }
if true the false else λx:Int . x
Propiedades (ejercicio)
Comprobar las siguientes equivalencias
para cualesquiera tipos A, B, C. En la
parte (3) asumir que existen los joins
(∧) indicados
A∨A=A,A∧A=A
A∨B=B∨A
A <: B ⇒ A ∨ B = B , A ∧ B = A
A ∨ (B ∨ C) = (A ∨ B) ∨ C ,
A ∧ (B ∧ C) = (A ∧ B) ∧ C
Caso de repaso
Dar una regla de tipado para la
expresión
case t of { v1 → r1, …, vn → rn }
Pista: pueden utilizarse joins según
sea necesario
Super temas - Conclusión
Relaciones de base entre tipos
Coercion semantics
Mención de otros formalismos
Concurrencia y canales
λ<=
Opus
λζ
Fun
λ&
F<=
π-cálculo
Pict
Subtipado con tipos recursivos
Continuará