Extensions de PTS Entiers, floats, ... Tuples, Structures, Records, ... Algebraic data types Types r´ecursifs Types existentiels

Extensions de PTS

Entiers, floats, ...

Tuples, Structures, Records, ...

Algebraic data types Types r ´ecursifs

Types existentiels

Types r ´ecursifs

G ´en ´eralement d ´enot ´es:

least fixed point:

µf = µx.f x ' f (f (f (f (...(f (⊥))))))

greatest fixed point:

νf = νx.f x ' f (f (f (f (...(f (>))))))

List α = µ (λl → ^Unit + (α × l)) Stream α = ν (λl → (α × l))

µ

Stream

µ

ν

Egalit ´e des types r ´ecursifs ´

type List1 α | nil | cons α ^(List1 α ^);

type List2 α | nil | cons α ^(List1 α ^);

type List3 α | nil | cons α ^(List4 α ^);

type List4 α | nil | cons α ^(List3 α ^);

Ces types sont-ils tous ´egaux?

Iso- vs ´ Equi- r ´ecursion

Deux s ´emantiques possibles:

equirecursive types:

µf = f (µf )

isorecursive types:

Γ ` e : µf

Γ ` <sup>unroll</sup> e : f (µf ) Γ ` e : f (µf )

Γ ` ^roll e : µf

roll

unroll

List1

List3

roll

unroll

R ´ecursion ”impropre”

type Tree α ^{| leaf} α | node (Tree ( α × α ⁾⁾ Tree = µ (λ(t : ^Type → ^Type )

→ λ(α : ^Type ) → α + t (α × α))

Complique encore plus l’implantation des types ´equir ´ecursifs

Γ ` e : (µ f ) τ

... τ

Γ ` ^unroll e : f (µ f ) τ

... τ

Γ ` e : f (µ f ) τ

... τ

Γ ` ^roll e : (µ f ) τ

... τ

Quantification existentielle

Utile quand un type ne sera connu qu’ `a l’ex ´ecution:

filter

:

α n → ∃n

.

α n;

Essayons d’encoder la quantification universelle:

∃t.τ ' ¬∀t.¬t

∃t : κ.τ ' ((t : κ) → t →

) →

Utilisable pour des preuves

Renvoyer toujours False est probl ´ematique dans des programmes

⇒

Types existentiels

∃t : κ.τ ' (α : ^Type ) → ((t : κ) → τ → α) → α

Introduction (parfois d ´enot ´e

ht = τ, e : f i

Γ ` e : f τ

Γ ` ^pack τ e : ∃t : κ.f t

Elimination (parfois d ´enot ´e´

open e

... ⁱⁿ e

Γ ` e

: ∃t : κ.τ

Γ, t : κ, x : τ

` e

: τ

Γ ` ^{let pack} t x = e

ⁱⁿ e

: τ

Types existentiels (exemples)

Une liste de taille non-sp ´ecifi ´ee:

List α ' ∃n : ^Nat . ^NList α n

Une repr ´esentation de fermeture:

τ

→ τ

' ∃

: ^Type . ^Pair ((τ

,

) → τ

)

O `u l’appelle `a une telle fermeture

f

let pack t x = f in

let code = x.1 // code : ( τ

^{, t)} → τ

let env = x.2 // env : t

Existentiels = paires d ´ependantes

∃t : κ.τ ' (α : ^Type ) → ((t : κ) → τ → α) → α

Rappelons l’encodage de Church des paires:

Pair

τ

τ

' (α : ^Type ) → (τ

→ τ

→ α) → α

Diff ´erences:

•

•

G ´en ´eralisation

Existentiels deviennent un cas particulier:

type Exists k f

| pack (t : k) (f t);

type Closure t

t

| closure (ctx : Type)

((t

× ^ctx) → ^t

⁾

ctx;