Mini-ML Mini language fonctionnel, pur: (types

Mini-ML

Mini language fonctionnel, pur:

(types)

τ ::= ^Int | ^Bool | τ

₁

→ τ

₂

(exps)

e ::= c | x | λx → e | e

₁

e

₂

| e : τ

let x = e

₁

ⁱⁿ e

₂

| ^if e

₁

^then e

₂

^else e

₃

Ajout d’effets de bord:

(types)

τ ::= ... | ^ref τ | ^Unit

(expressions)

e ::= ... | ^ref e | !e | e

₁

:= e

₂

| e

₁

; e

₂

Typage bidirectionnel

Au lieu de

Γ ` e : τ

Le typage bidirectionnel utilise 2 jugements:

Γ ` e ⇒ τ Γ ` e ⇐ τ

R `egle habituelle: constructeurs v ´erifi ´es, ´eliminations inf ´er ´ees Souvent suffisant pour ´eliminer annotations sauf sur

let

Exprime un algorithme avec 2 fonctions mutuellements r ´ecursives:

infer

:

Ctx

→

Exp

→

Typ

check

:

Ctx

→

Exp

→

Typ

→

Unit

S ´emantique statique de Mini-ML pur

(type ctx)

Γ ::= • | Γ, x : τ Γ(x) = τ

Γ ` x ⇒ τ

Γ ` e

₁

⇒ τ

₁

→ τ

₂

Γ ` e

₂

⇐ τ

₁

Γ ` e

₁

e

₂

⇒ τ

₂

Γ, x : τ

₁

` e ⇐ τ

₂

Γ ` λx → e ⇐ τ

₁

→ τ

₂

Γ ` e ⇐ τ Γ ` e : τ ⇒ τ

Γ ` e ⇒ τ Γ ` e ⇐ τ

Γ ` e

₁

⇐ ^Bool Γ ` e

₂

⇐ τ Γ ` e

₃

⇐ τ Γ ` ^if e

₁

^then e

₂

^else e

₃

⇐ τ

Γ ` e

₁

⇒ τ

₁

Γ, x : τ

₁

` e

₂

⇔

^a

τ

₂

Γ ` ^let x = e

₁

ⁱⁿ e

₂

⇔

^a

τ

₂

Pseudocode de l’algorithme bidirectionnel

infer Γ ^{e = case e}

| Evar x => lookup Γ ^x

| Eapply e

₁

e

₂

=> case infer Γ ^e

1

| Tarw t

₁

t

₂

=> check Γ ^e

2

t

₁

; t

₂

| Eannot e t => check Γ ^{e t; t} ...

check Γ e t = case e

| Elam x e => case t

| Tarw t

₁

t

₂

=> check (extend Γ ^{x t}

₁

^{) e t}

₂

| Eif e

₁

e

₂

e

₃

=>

check Γ ^e

₁

Tbool; check Γ ^e

₂

^{t; check} Γ ^e

₃

^t ...

| _ => assert (t = infer Γ ^e)

S ´emantique dynamique de Mini-ML pur

(values)

v ::= λx → e | c v

₁

... v

_n

R ´eductions primitives:

(+) n

₁

n

₂

; n

₃ where

n

₃

= n

₁

+ n

₂

(λx : τ → e) v ; e[v/x]

let x = v ⁱⁿ e ; e[v/x]

e : τ ; e

if True then e

₂

^else e

₃

; e

₂

if False then e

₂

^else e

₃

; e

₃

S ´emantique dynamique de Mini-ML pur (suite)

R `egles de congruence:

e

₁

; e

⁰₁

e

₁

e

₂

; e

⁰₁

e

₂

e ; e

⁰

v e ; v e

⁰

e

₁

; e

⁰₁

let x = e

₁

ⁱⁿ e

₂

; ^let x = e

⁰₁

ⁱⁿ e

₂

e

₁

; e

⁰₁

if e

₁

^then e

₂

^else e

₃

; ^if e

⁰₁

^then e

₂

^else e

₃

Ou aussi:

(exps avec trou)

E ::= • | E e | v E | ^let x = E ⁱⁿ e |

if E ^then e

₂

^else e

₃

Typage avec effets de bord

...

Γ ` e ⇒ τ

Γ ` ^ref e ⇒ ^ref τ

Γ ` e ⇒ <sup>ref</sup> τ Γ ` !e ⇒ τ

Γ ` e

₁

⇐ ^Unit Γ ` e

₂

⇔

^a

τ

₂

Γ ` e

₁

; e

₂

⇔

^a

τ

₂

Γ ` e

₁

⇒ ^ref τ Γ ` e

₂

⇐ τ

Γ ` e

₁

:= e

₂

⇒ ^Unit

S ´emantique dynamique avec effets de bord?

e ; e

⁰ n’est plus suffisant, on a besoin de m ´emoire!

Nouvelles valeurs, renvoy ´ees par

ref e

et

e

₁

:= e

₂: (values)

v ::= ... | () | `

(heap)

M ::= • | M, ` 7→ v

Voyons d’abord une s ´emantique `a grands pas:

(M ; e) ↓ (M

⁰

; v )

Evaluer´

e

dans le tas

M

renvoie la valeur

v

avec un nouveau tas

M

⁰

Effets de bord `a grands pas, partie pure

(M ; v) ↓ (M ; v) (M ; e) ↓ (M

⁰

; v) (M ; e : τ ) ↓ (M

⁰

; v)

(M ; e

₁

) ↓ (M

₁

; λx → e) (M

₁

; e

₂

) ↓ (M

₂

; v

₂

) (M

₁

; e[v

₂

/x]) ↓ (M

⁰

; v) (M ; e

1

e

2

) ↓ (M

⁰

; v)

(M ; e

1

) ↓ (M

1

; v

1

) (M

1

; e

2

[v

1

/x]) ↓ (M

⁰

; v) (M ;

^let

x = e

₁ ⁱⁿ

e

₂

) ↓ (M

⁰

; v)

(M ; e

1

) ↓ (M

1

; v

1

) (M

1

; e) ↓ (M

⁰

; v) e =







e

₂

if v

₁

= ^True e

₃

if v

₁

= ^False (M ;

^if

e

1 then

e

2 else

e

3

) ↓ (M

⁰

; v)

¡L’existence de

:=

oblige `a changer les r `egles pures!

Effets de bord `a grands pas, partie impure

(M ; e) ↓ (M

⁰

; v) ` fresh (M ;

^ref

e) ↓ (M

⁰

, ` 7→ v; `)

(M ; e) ↓ (M

⁰

; `) M

⁰

(`) = v (M ; !e) ↓ (M

⁰

; v)

(M ; e

₁

) ↓ (M

₁

; `) (M

₁

; e

₂

) ↓ (M

⁰

; v) (M ; e

1

:= e

2

) ↓ (M

⁰

, ` 7→ v; v)

(M ; e

₁

) ↓ (M

₁

; v

₁

) (M

₁

; e

₂

) ↓ (M

⁰

; v)

(M ; e

1

; e

2

) ↓ (M

⁰

; v))

Des expressions et des valeurs

Le r `egle d’ ´evaluation des valeurs est formellement incorrecte

(M ; v) ↓ (M ; v)

Parce qu’ `a gauche on doit avoir une expression:

•

Les valeurs

v

ne sont plus un sous-ensemble des expressions

e

! Il faut

(M ; c) ↓ (M ; c)

,

(M ; λx → e) ↓ (M ; λx → e)

, ...

Pour les petits pas, c¸a ne suffit pas; il faut ´etendre

e

: (exps)

e ::= ... | `

ou m ˆeme

(exps)

e ::= ... | v

Effets de bord `a petits pas, partie pure

R ´eductions primitives:

(M ; (+) n

₁

n

₂

) ; (M ; n

₃

)

where

n

₃

= n

₁

+ n

₂

(M ; (λx : τ → e) v) ; (M ; e[v/x])

(M ; ^let x = v ⁱⁿ e) ; (M ; e[v/x]) (M ; e : τ ) ; (M ; e)

(M ; if True then e

₂

^else e

₃

) ; (M ; e

₂

) (M ; if False then e

₂

^else e

₃

) ; (M ; e

₃

)

Rien de chang ´e, mis `a part l’ajout du

M

partout

Effets de bord `a petits pas, partie impure

R ´eductions primitives:

(M ; ^ref v ) ; (M, ` 7→ v; `)

where

` <sup>fresh</sup> (M ; !`) ; (M ; v)

where

M (`) = v (M ; ` := v ) ; (M, ` 7→ v; ())

(M ; (); e) ; (M ; e)

(exps avec trou)

E ::= • | E e | v E | ^let x = E ⁱⁿ e

| ^if E ^then e

₂

^else e

₃

| ^ref E | !E | E := e | v := E | E ; e

R `egles de typage valides?

Comment s’assurer de la validit ´e des r `egles de typage?

Si

e : τ

, la valeur

v

retourn ´ee par

e

devrait avoir type

τ

La coh ´erence (soundness) des r `egles peut se d ´ecomposer en:

•

pr ´eservation des types: Si

e : τ

et

e ; e

⁰ alors

e

⁰

: τ

•

progr `es: Si

e : τ

, ou

e ; e

⁰ ou

e

est une valeur Ensemble, cela donne:

Si

e : τ

et

e ;

^∗

e

⁰

,

alors

e

⁰ n’est pas stuck: ou

e

⁰

; e

⁰⁰ ou

e

⁰ est une valeur

“well-typed programs do not go wrong”

Coh ´erence du typage de Mini-ML?

En g ´en ´eral, progr `es ne s’applique que dans un environnement vide:

Si

• ` e : τ

, alors ou

(M ; e) ; (M

⁰

; e

⁰

)

ou

e

est une valeur Pr ´eservation des types implique, par exemple:

Vu que

• `

^ref

4 :

^{ref Int} et

(M ;

^ref

4) ; (M, ` 7→ 4; `)

alors

• ` ` :

^{ref Int}

Il nous faut donc une r `egle de typage pour

`

:

?

Γ ` ` : τ Ψ

donnera un type `a chaque adresse:

(heap type)

Ψ ::= • | Ψ, ` : τ

Nouveaux jugements de typage

Il faut v ´erifier que

Ψ

est bien le type de

M

, avec

` M : Ψ

:

Ψ ` M : Ψ

` M : Ψ Ψ ` • : •

Ψ ` M : Ψ

⁰

Ψ; • ` v ⇐ τ Ψ ` M, ` 7→ v : Ψ

⁰

, ` : τ

Et les jugements prennent maintenant la forme:

Ψ; Γ ` e ⇔

^a

τ Γ(x) = τ

Ψ; Γ ` x ⇒ τ · · · Ψ(`) = τ

Ψ; Γ ` ` ⇒ ^ref τ

Aucun jugement ne modifie

Ψ

, e.g.:

Ψ; Γ ` e ⇒ τ

Ψ; Γ ` ^ref e ⇒ ^ref τ

Ψ; Γ ` e

₁

⇒ ^ref τ Ψ; Γ ` e

₂

⇐ τ

Ψ; Γ ` e

₁

:= e

₂

⇒ ^Unit

Coh ´erence du typage de Mini-ML

Progr `es:

Si

` M : Ψ ∧ Ψ; • ` e ⇐ τ

alors

(M ; e) ; (M

⁰

; e)

⁰

∨ e

est une valeur Pr ´eservation des types:

Si

` M : Ψ ∧ Ψ; Γ ` e ⇐ τ ∧ (M ; e) ; (M

⁰

; e)

⁰

alors

∃Ψ

⁰

. ` M : Ψ

⁰

∧ Ψ

⁰

; Γ ` e

⁰

⇐ τ

Preuve de pr ´eservation des types

Dans le cas o `u

e = (λx : τ → e

₁

) v

et

e

⁰

= e

₁

[v/x]

, on doit prouver

Ψ; Γ ` e

₁

[v/x] ⇐ τ

₂,

sachant que

Ψ; Γ, x : τ

₁

` e

₁

⇐ τ

₂ et

Ψ; Γ ` v ⇐ τ

₁

Lemme de substitution ressemble habituellement `a:

Si

Ψ; Γ, x : τ

₁

, Γ

⁰

` e : τ

₂

∧ Ψ; Γ ` v : τ

₁

alors

Ψ; Γ, Γ

⁰

` e[v/x] : τ

₂

Ce genre de lemme est r ´ecurrent dans les preuves de pr ´eservation

Preuve de progr `es

Dans le cas

e = e

₁

e

₂, si

e

₁ ou

e

₂ n’est pas une valeur,

alors on trouve imm ´ediatement un pas

e ; e

⁰ par induction,

sinon il nous faut prouver que

e = (λx → e

₃

) e

₂ pour appliquer

β

Lemme de formes canoniques ressemble habituellement `a:

Si

Ψ; • ` v : τ

₁

→ τ

₂

alors

v = λx → e

Ce genre de lemme est r ´ecurrent dans les preuves de progr `es