Singleton types et parametricity Singleton types

Singleton types et parametricity

Singleton types

•

•

Singleton types partout

∼

Probl `emes avec les types d ´ependants

Incompatibles avec:

•

•

•

•

•

Attrayant pour un assistant `a la preuve, mais:

GADTs: types “d ´ependants” sans arri `ere go ˆ ut

On remplace:

type Nat : Type | zero : Nat | succ : Nat -> Nat;

type NList (a : Type) (l : Nat)

| nnil : NList a zero

| ncons: a -> NList a l -> NList a (succ 1);

par

Zero : Type;

Succ : Type -> Type;

type NList a l

| nnil : NList a Zero

| ncons: a -> NList a l -> NList a (Succ 1);

GADTs

Pr ´eserve la “phase distinction”

Compatible avec les effets de bord, la compilation, ...

Disponible en Haskell, OCaml, Scala, ...

N ´ecessite une inf ´erence/v ´erification de types plus sophistiqu ´ee Se r ´eduit fondamentalement aux preuves d’ ´egalit ´e d’

Ω

La saveur des types d ´ependants, mais sans la d ´ependance

Typage des GADTs

Le probl `eme du typage des GADTs:

Le raffinement des types dans les branches

case (ys : NList a l)

| nnil => nnil

| ncons x xs => ncons x xs

Il faut se souvenir que

l =

Tenir compte des ces ´egalit ´es lors de v ´erification d’ ´egalit ´e d’autres types Plusieurs typages possibles

⇒

Le type de make-nlist?

Avec typage d ´ependent:

make-nlist : a -> (len : Nat) -> NList a len;

Avec GADTs:

make-nlist : a -> (len : ?Nat?) -> NList a ?len?;

Nat n’existe plus (ou du moins, pas comme type) len n’existe pas dans le monde des types

Les types singleton `a la rescousse

type singleton: un type qui n’a qu’une seule valeur possible

Par exemple Snat

n

n

make-nlist : ∀ len. a -> Snat len -> NList a len;

On a maintenant acc `es `a len dans les 2 mondes: types et valeurs Mais, toujours pas de types d ´ependents!

Mais il faut dupliquer certaines choses:

(+) : ∀ n1, n2. Snat n1 -> Snat n2

-> Snat (plus n1 n2);

Types singleton partout

Les types singleton sont ´equivalents aux types d ´ependants

Param ´etricit ´e

∀t.t → t

De m ˆeme, il n’y a pas de valeur de type

∀t.

→ t

Ceci peut se d ´eduire donc directement du type

La param ´etricit ´e est une propri ´et ´e g ´en ´erale `a partir de laquelle on peut prouver ces autres propri ´et ´es

Exemples

head

: ∀t.[t] → t f ◦

'

◦

f

(++)

: ∀t.[t] → [t] → [t]

f (x

y) '

f x

f y K : ∀t

, t

.t

→ t

→ t

f (K x y) ' K (f x) (g y )

zip

: ∀t

, t

.([t

], [t

])

→ [(t

, t

)]

zip

(

f x,

g y)

'

(f × g)

(x, y)

Mod `eles

Un mod `ele d’un langage est un mapping vers un formalisme standard Exemple:

Γ ` e : τ ⇒ J e K

∈ J τ K

J n K

⇒ n

J ^Int K

⇒ Z

Mod `ele pour System F

Pour la param ´etricit ´e, on d ´efini une sorte de mod `ele Les types sont traduits en relations binaires

e : τ ⇒ e J τ K e

Pour un type de base

τ

J

K :

⇔

= I

Si

J τ K = R : A ⇔ A

alors

J [τ ] K = R

: [A] ⇔ [A

]

Mod `ele de fonctions

Si

J τ

K : A ⇔ A

et

J τ

K : B ⇔ B

alors

J τ

→ τ

K : A → B ⇔ A

→ B

tel que

f J τ

→ τ

K f

∀x, x

. x J τ

K x

⇒ f x J τ

K f

x

Functions are related if they take

related input arguments to related output results

Mod `ele de polymorphisme

J ∀t.F t K : (∀t.F t) ⇔ (∀t

.F

t

)

soit

F

R : A ⇔ A

F R : F A ⇔ F

A

alors

f J ∀t.F t K f

∀A, A

, R : A ⇔ A

. f [A] (F R) f

[A

]

Polymorphic functions are related if they take related input types to related output values

Th ´eor `eme de param ´etricit ´e

Le th ´eor `eme de param ´etricit ´e, dit simplement:

Si

• ` e : τ

e J τ K e

Cela revient `a dire que le mod `ele est valide

Usage

Prenons notre premier exemple

f : ∀t. t → t

Le th ´eor `eme nous dit

∀x

, x

, R. x

R x

⇒ (f x

) R (f x

);

On peut alors l’instancier avec:

x

= x, x

= x, R = {(x, x)}

Ce qui nous donne:

(f x) R (f x) ⇒ (f x, f x) ∈ {(x, x)} ⇒ f x = x

Avec Curry-Howard

alors

J τ

→ τ

K : A → B ⇔ A

→ B

tel que

f J τ

→ τ

K f

∀x, x

. x J τ

K x

⇒ f x J τ

K f

x

Devient:

f J τ

→ τ

K f

= (x : A) → (x

: A

) → (P : x J τ

K x

)

→ (f x J τ

K f

x

)

A.K.A

J τ

→ τ

K = λf → λf

→ (x : A) → (x

: A

) → (P : x J τ

K x

)

→ (f x J τ

K f

x

)