Alice Troise - Lambda calcolo e tipi polimorfi - SELP

Polimorfismo parametrico 

e type reconstruction 

Alice Troise 

Università degli Studi di Firenze 

Polimorfismo parametrico – p. 1

Polimorfismo 


Polimorfismo 

La necessità di avere polimorfismo nei linguaggi nasce da due 

importanti obiettivi, in parte contrastanti: 


Polimorfismo 



riusabilità del codice 


Polimorfismo 




e 

typing statico (essendo le variabili legate ai tipi prima della fase 

runtime, siamo sicuri che quando il programma sarà in esecuzione non 

avverranno errori di tipo) 


Polimorfismo 




e 




Nel presente approfondimento viene descritto il polimorfismo 

parametrico implicito (parametri di tipo type e applicazioni di 

tipo non sono ammesse) applicato al linguaggio del λ-calcolo. 


Polimorfismo 




e 




Nel presente approfondimento viene descritto il polimorfismo 

parametrico implicito (parametri di tipo type e applicazioni di 

tipo non sono ammesse) applicato al linguaggio del λ-calcolo. 

Iniziamo col ricordare sintassi, semantica e typing del λ-calcolo. 


Sintassi del λ-calcolo 

t ::= termini : 

x variabile 

λx : T.t astrazione (a la Church) 

tt applicazione 

v ::= valori : 

λx : T.t astrazione 

T ::= tipi : 

T → T freccia 

Γ ::= contesti : 

∅ contesto vuoto 

Γ, x : T binding di variabile 


Estensione alla sintassi del λ-calcolo 

t ::= termini : 

true, false, 0 booleani e zero 

if t then t else t costrutto if 

succ t successore 

pred t predecessore 

iszero t test sullo zero 

v ::= valori : 

true, false booleani 

nv (0 o succ nv) valori numerici 

T ::= tipi : 

Nat, Bool naturali e booleani 


Semantica del λ-calcolo 

t1 → t ′ 1 

t1t2 → t ′ 1 t2 

t2 → t ′ 2 

v1t2 → v1t ′ 2 

(E-APP1) 

(E-APP2) 

(λx: T.t)v → [x ↦→ v]t (E-APPABS) 


Estensione alla semantica del λ-calcolo 

t1 → t ′ 1 

iszero t1 → iszero t ′ 1 

(E-ISZERO) 

iszero 0 → true (E-ISZEROZ) 

iszero(succ nv1) → false (E-ISZEROS) 

t1 → t ′ 1 

if t ′ 1 then t2 else t3 

(E-IF) 

if true then t2 else t3 → t2 (E-IFTRUE) 

if false then t2 else t3 → t3 (E-IFFALSE) 


Estensione alla semantica del λ-calcolo 

t1 → t ′ 1 

pred t1 → pred t ′ 1 

t1 → t ′ 1 

succ t1 → succ t ′ 1 

(E-PRED) 

(E-SUCC) 

pred(succ nv1) → nv1 (E-PREDSUCC) 

pred 0 → 0 (E-PREDZERO) 


Typing del λ-calcolo 

x : T ∈ Γ 

Γ ⊢ x : T 

Γ,x : T1 ⊢ t2 : T2 

Γ ⊢ λx : T1.t2 : T1 → T2 

Γ ⊢ t1 : T11 → T12 Γ ⊢ t2 : T11 

Γ ⊢ t1t2 : T12 

(T-VAR) 

(T-ABS) 

(T-APP) 


Estensione al typing del λ-calcolo 

Γ ⊢ true : Bool (T-TRUE) Γ ⊢ false : Bool (T-FALSE) 

Γ ⊢ 0 : Nat (T-ZERO) 

Γ ⊢ t1 : Nat 

Γ ⊢ succt1 : Nat 

(T-SUCC) 

Γ ⊢ t1 : Nat 

Γ ⊢ iszero t1 : Bool 

Γ ⊢ t1 : Nat 

Γ ⊢ predt1 : Nat 

Γ ⊢ t1 : Bool Γ ⊢ t2 : T Γ ⊢ t3 : T 

Γ ⊢ if t1 then t2 else t3 : T 

(T-IF) 

(T-ISZERO) 

(T-PRED) 


Variabili di tipo e sostituzioni 

Aggiungiamo al linguaggio del λ-calcolo, esteso coi valori 

numerici e qualche funzione, un insieme infinito A di tipi base 

non interpretati senza operazioni primitive associate. Questi tipi 

sconosciuti prendono il nome di variabili di tipo e vengono 

indicati con X, Y, Z, .... 


Variabili di tipo e sostituzioni 

Aggiungiamo al linguaggio del λ-calcolo, esteso coi valori 

numerici e qualche funzione, un insieme infinito A di tipi base 

non interpretati senza operazioni primitive associate. Questi tipi 

sconosciuti prendono il nome di variabili di tipo e vengono 

indicati con X, Y, Z, .... 

Il processo che assegna tipi concreti a variabili di tipo è chiamato 

sostituzione oppure istanziazione. 


Le due fasi della sostituzione 

È conveniente separare le operazioni di sostituzione in due parti: 




1. descrizione del mapping σ dalle variabili di tipo nei tipi, 

chiamato sostituzione 






2. applicazione del mapping ad un particolare tipo T per 

ottenere una istanza σT . 






2. applicazione del mapping ad un particolare tipo T per 

ottenere una istanza σT . 

֒→ Esempio: possiamo definire [X ↦→ Bool,Y ↦→ X → Int]. 

Se applichiamo σ al tipo X ↦→ X otteniamo Bool → Bool. 

Se applichiamo σ al tipo Y otteniamo X → Int. 


Sostituzione di tipo - definizione 

Def. Sostituzione di tipo: mapping finito σ da variabili di tipo 

in tipi. 



Def. Sostituzione di tipo: mapping finito σ da variabili di tipo 

in tipi. 

Scriviamo dom(σ) per indicare l’insieme delle variabili di tipo 

che appaiono a sinistra delle coppie di σ; range(σ) per l’insieme 

dei tipi che appaiono a destra. 



L’applicazione di una sostituzione ad un tipo è definita nel 

seguente modo: 

σ(X) = 

⎧ 

⎨ 

⎩ 

σ(Nat) = Nat 

σ(Bool) = Bool 

σ(T1 → T2) = σT1 → σT2 

T se (X ↦→ T) ∈ σ 

X se X /∈ dom(σ) 



La sostituzione di tipo si estende banalmente ad un contesto di 

assunzioni di tipo Γ definendo: 

σ(x1 : T1,...,xn : Tn) = (x1 : σT1,...,xn : σTn) 



La sostituzione di tipo si estende banalmente ad un contesto di 

assunzioni di tipo Γ definendo: 

σ(x1 : T1,...,xn : Tn) = (x1 : σT1,...,xn : σTn) 

Se σ e γ sono sostituzioni, scriviamo σ ◦ γ per identificare la 

sostituzione formata dalla composizione di esse: 

⎡ 

X ↦→ σ(T) per ogni (X ↦→ T) ∈ γ 

σ◦γ = ⎣ 

X ↦→ T per ogni (X ↦→ T) ∈ σ con X /∈ dom(γ) 

Si noti che (σ ◦ γ)S = σ(γS). 

⎤ 

⎦ 


Preservation del typing 

Teorema: Il buon tipaggio si preserva sotto sostituzione di tipo, 

ovvero ∀σ Γ ⊢ t : T ⇒ σΓ ⊢ σt : σT. 

Dimostrazione: Per induzione sulla derivazione del tipo 


Istanze di sostituzione valide 

Sia t un termine contenente variabili di tipo, Γ un contesto 

associato; ci chiediamo se può essere istanziato a un termine ben 

tipato scegliendo appropriati valori per le sue variabili di tipo. 






֒→ Per esempio, sia Γ = {f : F, x : X} e sia t = fx. t non è tipabile così 

com’è, ma lo può essere con una qualsiasi delle seguenti sostituzioni: 

[F ↦→ Nat → Bool, X ↦→ Nat] ed in questo modo ha tipo Bool. 

[F ↦→ X → Nat] ed in questo modo t ha tipo Nat; 

[F ↦→ X → Y] ed in questo modo ha tipo Y; 






֒→ Per esempio, sia Γ = {f : F, x : X} e sia t = fx. t non è tipabile così 

com’è, ma lo può essere con una qualsiasi delle seguenti sostituzioni: 

[F ↦→ Nat → Bool, X ↦→ Nat] ed in questo modo ha tipo Bool. 

[F ↦→ X → Nat] ed in questo modo t ha tipo Nat; 

[F ↦→ X → Y] ed in questo modo ha tipo Y; 

La ricerca di istanze di sostituzione valide porta all’idea di type 

reconstruction (o type inference), nella quale il compilatore 

completa le informazioni di tipo non specificate dal 

programmatore. 


Verso un typing vincolato 

Nelle prossime slides presenteremo un algoritmo che, dato un 

termine t ed un contesto Γ, trova le condizioni minime sulle loro 

variabili di tipo per rendere t ben tipato. 


Verso un typing vincolato 

Nelle prossime slides presenteremo un algoritmo che, dato un 

termine t ed un contesto Γ, trova le condizioni minime sulle loro 

variabili di tipo per rendere t ben tipato. 

La differenza con l’ordinario algoritmo di typechecking è che, 

invece di controllare che siano soddisfatte certe condizioni, le 

registra per una considerazione successiva. 


Vincoli - definizioni 

Un insieme di vincoli (constraint) C è un insieme di equazioni 

C = {S1 = T1, S2 = T2, ..., Sn = Tn}. 


Vincoli - definizioni 

Un insieme di vincoli (constraint) C è un insieme di equazioni 

C = {S1 = T1, S2 = T2, ..., Sn = Tn}. 

Si dice che una sostituzione σ unifica un’equazione Si = Ti se 

σSi = σTi. 

Si dice che σ soddisfa C se σ unifica tutte le equazioni di C. 


Typing basato sui vincoli 

La relazione Γ ⊢ t : T|χC è letta “il termine t ha tipo T nel 

contesto delle assunzioni Γ ogni qual volta i vincoli C sono 

soddisfatti”. 


Typing basato sui vincoli 

La relazione Γ ⊢ t : T|χC è letta “il termine t ha tipo T nel 

contesto delle assunzioni Γ ogni qual volta i vincoli C sono 

soddisfatti”. 

Il simbolo χ è usato per tenere traccia delle variabili di tipo 

introdotte; tali annotazioni assicurano che: 

1. ogni qual volta una variabile di tipo è scelta dalla regola 

finale di una certa derivazione, è sicuro che essa è diversa 

da ogni altra variabile scelta fra le sotto-derivazioni; 

2. ogni volta che una regola coinvolge due o più 

sotto-derivazioni, gli insiemi delle variabili scelte da tali 

sotto-derivazioni sono disgiunti. 


Regole typing con vincoli 1 

x : T ∈ Γ 

Γ ⊢ x : T|∅{} 

Γ, x : T1 ⊢ t2 : T2|χC 

Γ ⊢ λx : T1.t2 : T1 → T2|χC 

Γ ⊢ t1 : T1|χ1C1 Γ ⊢ t2 : T2|χ2C2 

χ1 ∩ χ2 = χ1 ∩ FV (T2) = χ2 ∩ FV (T1) = ∅ 

X /∈ χ1,χ2, T1, T2, C1, C2, Γ, t1, t2 

Γ ⊢ t1t2 : X|χ1∪χ2∪{X}C1 ∪ C2 ∪ {T1 = T2 → X} 

dove indichiamo con FV(T) l’insieme di tutte le variabili di tipo 

menzionate in T. 

(CT-VAR) 

(CT-ABS) 

(CT-APP) 



Γ ⊢ true : Bool|∅{} (CT-TRUE) 

Γ ⊢ false : Bool|∅{} (CT-FALSE) 

Γ ⊢ t1 : T1|χ1C1 Γ ⊢ t2 : T2|χ2C2 Γ ⊢ t3 : T3|χ3C3 

χ1,χ2,χ3 nonoverlapping 

Γ ⊢ if t1 then t2 else t3 : T2|χ1∪χ2∪χ3 C ′ 

dove C ′ = C1 ∪ C2 ∪ C3 ∪ {T1 = Bool, T2 = T3} 

(CT-IF) 



Γ ⊢ 0 : Nat|∅{} (CT-ZERO) 

Γ ⊢ t1 : T|χC 

Γ ⊢ predt1 : Nat|χC ∪ {T = Nat} 

Γ ⊢ t1 : T|χC 

Γ ⊢ succt1 : Nat|χC ∪ {T = Nat} 

Γ ⊢ t1 : T|χC 

Γ ⊢ iszero t1 : Bool|χC ∪ T = Nat 

(CT-PRED) 

(CT-SUCC) 

(CT-ISZERO) 


Osservazioni 

• Il sistema di typing con vincoli è guidato dalla sintassi del 

linguaggio. 


Osservazioni 


linguaggio. 

• Le regole definiscono una procedura deterministica, 

ovvero un algoritmo che dato un termine t ed un contesto Γ 

ricava il tipo T e l’insieme C tali che Γ ⊢ t : T|χC. 


Osservazioni 


linguaggio. 

• Le regole definiscono una procedura deterministica, 

ovvero un algoritmo che dato un termine t ed un contesto Γ 

ricava il tipo T e l’insieme C tali che Γ ⊢ t : T|χC. 

• Questo algoritmo non fallisce mai: per ogni Γ e per ogni t 

vi è sempre un tipo T ed un contesto C tali che Γ ⊢ t : T|χC. 

Questo in quanto i vincoli non vengono verificati 

all’interno delle regole, ma vengono solo memorizzati in C 

per un’analisi successiva. 


Esempio di derivazione di tipo 

֒→ Derivazione di tipo per il termine λx : X. λy : Y.xy 

x : X ∈ Γ 

y : Y ∈ Γ 

{x : X, y : Y} ⊢ x : X| ∅{} {x : X, y : Y} ⊢ y : Y| ∅{} 

{x : X, y : Y} ⊢ (xy) : W| {W}{X = Y → W} 

{x : X} ⊢ λy : Y.(xy) : Y → W| {W}{X = Y → W} 

{} ⊢ λx : X. λy : Y.(xy) : X → Y → W| {W}{X = Y → W} 




x : X ∈ Γ 

y : Y ∈ Γ 

{x : X, y : Y} ⊢ x : X| ∅{} {x : X, y : Y} ⊢ y : Y| ∅{} 

{x : X, y : Y} ⊢ (xy) : W| {W}{X = Y → W} 



ricordando la regola CT-ABS: 

Γ, x : T1 ⊢ t2 : T2|χC 

Γ ⊢ λx : T1.t2 : T1 → T2|χC 




x : X ∈ Γ 

y : Y ∈ Γ 

{x : X, y : Y} ⊢ x : X| ∅{} {x : X, y : Y} ⊢ y : Y| ∅{} 

{x : X, y : Y} ⊢ (xy) : W| {W}{X = Y → W} 



ricordando la regola CT-ABS: 

Γ, x : T1 ⊢ t2 : T2|χC 

Γ ⊢ λx : T1.t2 : T1 → T2|χC 

ricordando la regola CT-APP: 

Γ ⊢ t1 : T1|χ1 C1 Γ ⊢ t2 : T2|χ2 C2 

χ1 ∩ χ2 = χ1 ∩ FV (T2) = χ2 ∩ FV (T1) = ∅ X fresh 

Γ ⊢ t1t2 : X| χ1∪χ2∪{X}C1 ∪ C2 ∪ {T1 = T2 → X} 


Osservazioni pratiche 

Normalmente la costruzione della derivazione coi vincoli non 

avviene con un solo passaggio; ciò significa che inizialmente 

verranno identificati i tipi delle variabili senza supporre alcunchè 

sui vincoli (raggiungeremo cioè la cima della derivazione in 

modo bottom up). Successivamente, a partire dalla parte alta 

della derivazione (ovvero dalla definizione degli elementi 

inizialmente appartenenti al contesto), verranno costruiti 

l’insieme dei vincoli ed il tipo S mediante l’applicazione delle 

regole semantiche. 


Soluzioni 

Soluzione per (Γ, t) 

Sia Γ un contesto di assunzioni di tipo e t un termine. Una 

soluzione per (Γ, t) è una coppia (σ, T) tale che σΓ ⊢ σt : T. 

Soluzione per (Γ, t, S, C) 

Sia Γ ⊢ t : S|C. Una soluzione per (Γ, t, S, C) è una coppia 

(σ, T) tale che σ soddisfa C e σS = T. 


Soluzioni 

Soluzione per (Γ, t) 

Sia Γ un contesto di assunzioni di tipo e t un termine. Una 

soluzione per (Γ, t) è una coppia (σ, T) tale che σΓ ⊢ σt : T. 

Soluzione per (Γ, t, S, C) 

Sia Γ ⊢ t : S|C. Una soluzione per (Γ, t, S, C) è una coppia 

(σ, T) tale che σ soddisfa C e σS = T. 

Correttezza: Sia Γ ⊢ t : S|C. Se (σ, T) è una soluzione per 

(Γ, t, S, C), allora è anche una soluzione per (Γ, t). 

Completezza: Sia Γ ⊢ t : S|C. Se (σ, T) è una soluzione per 

(Γ, t), allora è anche una soluzione per (Γ, t, S, C). 

Dimostrazione: per induzione (si veda Pierce [1]) 


Completezza del typing vincolato 

In realtà la formulazione del teorema di completezza è 

leggermente diversa. 

Def.: σ\χ è una sostituzione indefinita per tutte le variabili in χ 

e con le altre si comporta come σ. 

Teorema di completezza: Sia Γ ⊢ t : S|C. Se (σ, T) è una 

soluzione per (Γ, t) e dom(σ) ∩ χ = ∅ allora esiste una 

soluzione (σ ′ , T) per (Γ, t, S, C) tale che σ ′ \χ = σ. 


Unificazione 

Per calcolare le soluzioni di un insieme di vincoli usiamo 

l’algoritmo di unificazione di Robinson (1971). 


Unificazione 



Def. Sostituzione meno specifica: Una sostituzione σ è meno 

specifica (o più generale) di una sostituzione σ ′ , scritto σ ⊑ σ ′ , 

se σ ′ = γ ◦ σ per qualche sostituzione γ. 


Unificazione 






Def. Unificatore principale: Un unificatore principale per un 

insieme di vincoli C è una sostituzione σ che soddisfa C e tale 

che σ ⊑ σ ′ per ogni sostituzione σ ′ che soddisfa C. 


Unificazione 






Def. Unificatore principale: Un unificatore principale per un 

insieme di vincoli C è una sostituzione σ che soddisfa C e tale 

che σ ⊑ σ ′ per ogni sostituzione σ ′ che soddisfa C. 

Def. Algoritmo di unificazione: Vedi pseudo-codice nella 

prossima slide. 


Algoritmo di unificazione 

unify(C) = 

- if C = ∅ then [ ] 

- else let {S = T} ∪ C ′ = C in 



unify(C) = 

- if C = ∅ then [ ] 


- if S = T 

- then unify(C ′ ) 

- else if S = X and X /∈ FV(T) 

- then unify([X ↦→ T]C ′ ) ◦ [X ↦→ T] 

- else if T = X and X /∈ FV(S) 

- then unify([X ↦→ S]C ′ ) ◦ [X ↦→ S] 



unify(C) = 

- if C = ∅ then [ ] 


- if S = T 






- else if S = S1 → S2 and T = T1 → T2 

- then unify(C ′ ∪ {S1 = T1, S2 = T2}) 



unify(C) = 

- if C = ∅ then [ ] 


- if S = T 






- else if S = S1 → S2 and T = T1 → T2 

- then unify(C ′ ∪ {S1 = T1, S2 = T2}) 

- else 

- fail 


Osservazioni su unify 

• La frase “let {S = T}∪C ′ = C” alla seconda linea deve 

essere intesa come “si scelga un vincolo S = T dall’insieme 

C e sia C ′ l’insieme che denota i rimanenti vincoli di C. 






• Le condizioni di lato X /∈ FV(T) e X /∈ FV(S) sono note 

come occur check. Servono per impedire all’algoritmo di 

generare una soluzione che contenga una sostituzione 

ciclica come ad esempio X ↦→ X → X. 






• Le condizioni di lato X /∈ FV(T) e X /∈ FV(S) sono note 

come occur check. Servono per impedire all’algoritmo di 

generare una soluzione che contenga una sostituzione 

ciclica come ad esempio X ↦→ X → X. 

• Nel nostro caso il fallimento dell’algoritmo può avvenire o 

per occur check o perché tentiamo di unificare Nat = Bool. 


Proprietá di unify 

Teorema (Milner): 

1. unify(C) termina per ogni C; 

2. se unify(C)=σ, allora σ è un unificatore per C; 

3. se δ è un unificatore per C, allora unify(C)=σ con σ ⊑ δ 

Dimostrazione: Vedi Pierce [1] 


Soluzione principale 

Def. Soluzione e tipo principale: Una soluzione principale per 

(Γ, t, S, C) è una soluzione (σ, T) tale che, per ogni altra 

soluzione (σ ′ , T ′ ) si ha che σ ⊑ σ ′ . In tal caso T è detto il tipo 

principale di t. 

Teorema (Soluzione principale): Se (Γ, t, S, C) ha soluzione, 

allora ne ha una principale. L’algoritmo di unificazione può 

essere usato per determinare se (Γ, t, S, C) ha soluzione e, in 

caso positivo, per trovare la principale. 


Isomorfismo di Curry-Howard 

È stato dimostrato che ogni derivazione nel frammento implicazionale 

della logica proposizionale intuizionistica corrisponde ad un termine 

à la Church (ovvero esplicitamente tipato) tipabile nel λ-calcolo. 






Dato che la sintassi delle formule della logica intuizionistica è analoga 

a quella della logica del primo ordine, possiamo dedurre, data l’assenza 

dei quantificatori, che il sistema di tipi basato sui vincoli è un 

sottoinsieme dela logica del primo ordine: i tipi Nat e Bool sono 

costanti, le variabili di tipo sono variabili del calcolo e → è un simbolo 

funzionale binario. 






Dato che la sintassi delle formule della logica intuizionistica è analoga 

a quella della logica del primo ordine, possiamo dedurre, data l’assenza 

dei quantificatori, che il sistema di tipi basato sui vincoli è un 

sottoinsieme dela logica del primo ordine: i tipi Nat e Bool sono 

costanti, le variabili di tipo sono variabili del calcolo e → è un simbolo 

funzionale binario. 

In questo contesto l’algoritmo di type reconstruction assume il ruolo di 

theorem prover. 


Sistemi formali e typechecking 

Per approcciare la semantica formale dei tipi è possibile usare modelli 

matematici per i tipi (mappando ogni espressione di tipo in un insieme 

di valori) o definire un sistema formale di assiomi e regole di 

inferenza nel quale è possibile provare che un’espressione ha un 

qualche tipo. Questi approcci sono complementari: un modello 

semantico è spesso una guida nel definire un sistema formale; d’altra 

parte ogni sistema formale deve essere self-consistent e questo si 

dimostra spesso presentando un modello. 


Sistemi formali e typechecking 

Per approcciare la semantica formale dei tipi è possibile usare modelli 

matematici per i tipi (mappando ogni espressione di tipo in un insieme 

di valori) o definire un sistema formale di assiomi e regole di 

inferenza nel quale è possibile provare che un’espressione ha un 

qualche tipo. Questi approcci sono complementari: un modello 

semantico è spesso una guida nel definire un sistema formale; d’altra 

parte ogni sistema formale deve essere self-consistent e questo si 

dimostra spesso presentando un modello. 

Poiché sintattico, il typechecking è collegato più ai sistemi formali che 

ai modelli. Un algoritmo di typechecking implementa un sistema 

formale, fornendo una procedura per dimostrare teoremi in quel 

sistema. Se ha successo nel trovare un tipo per una espressione, allora 

tale tipo può essere dedotto dal sistema di inferenza; inoltre è possibile 

dedurre l’algoritmo di typechecking a partire dal sistema di inferenza. 


Un sistema di inferenza 

Esistono due distinti modi di vedere il typechecking: uno 

consiste nel risolvere un sistema di equazioni di tipo, l’altro 

consiste nel provare teoremi in un sistema formale. 

Cardelli [2] presenta un sistema di assiomi e regole d’inferenza, 

con le quali è possibile ottenere le medesime deduzioni (o 

derivazioni) costruite con le regole di typing con vincoli. Qui ne 

presentiamo una piccola parte. 



Esistono due distinti modi di vedere il typechecking: uno 

consiste nel risolvere un sistema di equazioni di tipo, l’altro 

consiste nel provare teoremi in un sistema formale. 

Cardelli [2] presenta un sistema di assiomi e regole d’inferenza, 

con le quali è possibile ottenere le medesime deduzioni (o 

derivazioni) costruite con le regole di typing con vincoli. Qui ne 

presentiamo una piccola parte. 

Premessa: Indicheremo i tipi con lettere minuscole greche e gli 

insiemi di assunzioni xi : τi con lettere latine maiuscole. 

Un tipo è chiamato shallow (superficiale) se ha la forma 

∀α1, ..., ∀αn.τ dove n ≥ 0 senza quantificatori in τ. 

Siamo interessati solo ai tipi shallow. 



A ⊢ e : τ 

A ⊢ e : ∀α.τ 

A.x : τ ⊢ x : τ [IDE] 

(α non libera in A) [GEN] 

A.x : σ ⊢ e : τ 

A ⊢ λx.e : σ → τ [ABS] 

A ⊢ e : ∀α.τ 

A ⊢ e : τ[σ/α] 

[SPEC] 



A ⊢ e : τ 

A ⊢ e : ∀α.τ 

A.x : τ ⊢ x : τ [IDE] 


A.x : σ ⊢ e : τ 

A ⊢ λx.e : σ → τ [ABS] 

A ⊢ e : ∀α.τ 

A ⊢ e : τ[σ/α] 

֒→Esempio: possiamo dedurre il tipo principale per la funzione 

identità nel seguente modo: 

x : α ⊢ x : α 

⊢ λx.x : α → α 

⊢ λx.x : ∀α.α → α 

[SPEC] 



A ⊢ e : τ 

A ⊢ e : ∀α.τ 

A.x : τ ⊢ x : τ [IDE] 


A.x : σ ⊢ e : τ 

A ⊢ λx.e : σ → τ [ABS] 

A ⊢ e : ∀α.τ 

A ⊢ e : τ[σ/α] 

֒→Esempio: possiamo dedurre il tipo principale per la funzione 

identità nel seguente modo: 

x : α ⊢ x : α 

⊢ λx.x : α → α 

⊢ λx.x : ∀α.α → α 

Un tipo specializzato per la funzione identità può essere dedotto da 

questo con [SPEC]: 

⊢ λx.x : ∀α.α → α 

⊢ λx.x : Int → Int 

[SPEC] 


Il costrutto let 

Il costrutto let è utile sia per evitare ripetizioni che per aumentare 

la leggibilità del codice. 



Il costrutto let è utile sia per evitare ripetizioni che per aumentare 

la leggibilità del codice. È aggiunto al λ-calcolo aggiungendo 

alla sintassi dei termini 

e alla semantica 

let x = t in t 

let x = v1 in t2 → [x ↦→ v1]t2 (E-LETV) 

t1 → t ′ 1 

let x = t1 in t2 → let x = t ′ 1 

in t2 

(E-LET) 



Tali aggiunte non rappresentano un’estensione operazionalmente 

significativa del linguaggio, infatti let può essere simulato con 

una astrazione ed un’applicazione: 

let x = t1 in t2 ↔ (λx.t2)t1 


Il costrutto let ed i tipi 

Per quanto riguarda il sistema dei tipi otteniamo però un 

linguaggio più espressivo. 

֒→ Ad esempio, vorremmo poter tipare Id(Id) ↔ let z = (λx.x) in zz 





֒→ Ad esempio, vorremmo poter tipare Id(Id) ↔ let z = (λx.x) in zz , 

ma (λz.zz)(λx.x) non è tipabile. 






ma (λz.zz)(λx.x) non è tipabile. Infatti la sua derivazione è: 

z : Z ∈ {z : Z} z : Z ∈ {z : Z} 

{z : Z} ⊢ z : Z| ∅{} {z : Z} ⊢ z : Z| ∅{} 

{z : Z} ⊢ zz : Y| {Y}{Z = Z → Y} 

{} ⊢ λz : Z.zz : Z → Y| {Y}{Z = Z → Y} 

L’algoritmo di unificazione incorre in un fallimento per occur check: 

Z ∈ Var(Z → Y). 






ma (λz.zz)(λx.x) non è tipabile. Infatti la sua derivazione è: 

z : Z ∈ {z : Z} z : Z ∈ {z : Z} 

{z : Z} ⊢ z : Z| ∅{} {z : Z} ⊢ z : Z| ∅{} 

{z : Z} ⊢ zz : Y| {Y}{Z = Z → Y} 

{} ⊢ λz : Z.zz : Z → Y| {Y}{Z = Z → Y} 

L’algoritmo di unificazione incorre in un fallimento per occur check: 

Z ∈ Var(Z → Y). 

Modifichiamo quindi la regola di typing per il let in modo da 

eseguire prima del calcolo dei tipi il passo di valutazione 

let x = v1 in t2 → [x ↦→ v1]t2 


Annotazioni di tipo implicite 

Per avere un let polimorfo, innanzitutto aggiungiamo alla sintassi 

dei termini la λ-astrazione senza annotazioni di tipo, 

associandole la seguente nuova regola di typing: 

X /∈ χ Γ, x : X ⊢ t1 : T|χC 

Γ ⊢ λx.t1 : X → T|χ∪{X}C 

(CT-ABSINF) 


Il let polimorfo 

Adesso aggiungiamo una regola diretta di typing del let: 

Γ ⊢ t1 : T1 Γ ⊢ [x ↦→ t1]t2 : T2 

Γ ⊢ let x = t1 in t2 : T2 

(T-LET) 

Abbiamo controllato che anche t1 fosse ben tipato per tutelarci nel caso 

in cui x non occorre mai in t2. 

La regola per il sistema di vincoli è simile: 

Γ ⊢ t1 : T1|χ1C1 Γ ⊢ [x ↦→ t1]t2 : T2|χ2C2 

χ1 ∩ χ2 = ∅ 

Γ ⊢ let x = t1 in t2 : T2|χ1∪χ2{C1 ∪ C2} 

(CT-LETPOLY) 


Nuova type inference 

L’uso congiunto di CT-LETPOLY e di CT-ABSINF produce 

l’effetto desiderato: 

• CT-LETPOLY produce tutte le copie necessarie della 

definizione t1 e le sostituisce ovunque il nome x compare 

libero in t2; 

• la type reconstruction prosegue quindi su questa 

espressione espansa, dove con CT-ABSINF si assegna a 

ciascuna λ-astrazione una variabile di tipo diversa. 


Autoapplicazione dell’identità 

Le nuove regole introdotte permettono di tipare 

l’autoapplicazione dell’identità 

La derivazione è la seguente: 

x : X ∈ {x : X} 

(X fresh) 

{x : X} ⊢ x : X| ∅{} 

{} ⊢ λx.x : X → X| ∅{} 

let z = (λx.x) in zz 

x : Y ∈ {x : Y} 

(Y fresh) 

{x : Y} ⊢ x : Y| ∅{} 

x : Z ∈ {x : Z} 

(Z fresh) 

{x : Z} ⊢ x : Z| ∅{} 

{} ⊢ λ x.x : Y → Y| ∅{} {} ⊢ λ x.x : Z → Z| ∅{} 

{} ⊢ (λ x.x)(λ x.x) : W| {W}{Y → Y = (Z → Z) → W} 

{} ⊢ let z = (λx.x) inzz : W| {W}{Y → Y = (Z → Z) → W} 


Autoapplicazione dell’identità 

L’algoritmo di unificazione esegue i seguenti passi: 

unify({Y → Y = (Z → Z) → W}) 

1. S = Y → Y,T = (Z → Z) → W ⇒ 

⇒ unify({Y = Z → Z,Y = W}) 

2. S = Y and Y /∈ Var(Z → Z) ⇒ 

⇒ unify([Y ↦→ Z → Z]{Y = W}) ◦ [Y ↦→ Z → Z] 

⇒ unify({Z → Z = W}) ◦ [Y ↦→ Z → Z] 

3. T = W and W /∈ Var(Z → Z) ⇒ 

⇒ unify([W ↦→ Z → Z]∅) ◦ [W ↦→ Z → Z] ◦ [Y ↦→ Z → Z] 

⇒ [] ◦ [W ↦→ Z → Z] ◦ [Y ↦→ Z → Z] 

Abbiamo quindi σ = [W ↦→ Z → Z,Y ↦→ Z → Z], 

da cui si deduce che il tipo principale è σW = Z → Z. 


Possibili approfondimenti 

1) Le implementazioni pratiche del let-polimorfismo sono 

riformulazioni più efficienti: evitano che per ogni occorrenza 

della variabile nel corpo del let venga verificato il termine 

sostituito. 






sostituito. 

2) È possibile pensare di astrarre i tipi “fuori” dai termini per poi 

inserirli in un secondo momento; questo concetto ha portato allo 

sviluppo (Girard, 1972; Reynolds, 1974) di una nuova estensione 

del λ-calcolo con tipi semplici, chiamata System F. 






sostituito. 

2) È possibile pensare di astrarre i tipi “fuori” dai termini per poi 

inserirli in un secondo momento; questo concetto ha portato allo 

sviluppo (Girard, 1972; Reynolds, 1974) di una nuova estensione 

del λ-calcolo con tipi semplici, chiamata System F. 

Tale estensione corrisponde, in base all’isomorfismo di 

Curry-Howard, alla logica intuizionistica del secondo ordine, la 

quale permette quantificazioni sui predicati (ovvero sui tipi). 


Bibliografia 

1 Benjamin C.Pierce, Types and Programming Languages - 

cap. 22, MIT Press, 2002. 


Bibliografia 

1 Benjamin C.Pierce, Types and Programming Languages - 

cap. 22, MIT Press, 2002. 

2 Luca Cardelli, Basic Polimorphic Typechecking, AT&T Bel 

Laboratories, 1988. 


FINE 


FINE 

Grazie per l’attenzione

Alice Troise - Lambda calcolo e tipi polimorfi - SELP

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?