Table Of ContentIntersection types for unbind and rebind∗
MariangiolaDezani-Ciancaglini PaolaGiannini
Dip.diInformatica,Univ.diTorino,Italy Dip.diInformatica,Univ.delPiemonteOrientale,Italy
ElenaZucca
DISI,Univ.diGenova,Italy
Wedefineatypesystemwithintersectiontypesforanextensionoflambda-calculuswithunbindand
rebindoperators.Inthiscalculus,atermtwithfreevariablesx ,...,x ,representingopencode,can
1 n
bepackedintoanunboundtermhx ,...,x |ti, andpassedaroundasa value. Inordertoexecute
1 n
insidecode,anunboundtermshouldbeexplicitlyreboundatthepointwhereitisused. Unbinding
andrebindingarehierarchical,thatis,thetermtcancontainarbitrarilynestedunboundterms,whose
inside code can only be executed after a sequence of rebinds has been applied. Correspondingly,
types are decorated with levels, and a term has type t k if it needs k rebinds in order to reduce to
a value of type t . With intersectiontypeswe modelthe fact thata term can be used differentlyin
contexts providing different numbers of unbinds. In particular, top-level terms, that is, terms not
requiringunbindsto reduceto values, shouldhavea valuetype, thatis, an intersectiontype where
atleastoneelementhaslevel0. Withtheproposedintersectiontypesystemwegetsoundnessunder
thecall-by-valuestrategy,anissuewhichwasnotresolvedbyprevioustypesystems.
Introduction
Inpreviouswork[12,13]weintroduced anextensionoflambda-calculus withunbindandrebindopera-
tors,providingasimpleunifyingfoundationfordynamicscoping,rebindinganddelegationmechanisms.
Thisextensionreliesonthefollowingideas:
• A term hG |ti, where G is a set of typed variables called unbinders, is a value, of a special type
code,representing “opencode”whichmaycontainfreevariables inthedomainofG .
• Tobeused,opencodeshouldbereboundthroughtheoperatort[r],whererisa(typed)substitution
(a map from typed variables to terms). Variables in the domain of r are called rebinders. When
therebindoperatorisappliedtoatermhG |ti,adynamiccheckisperformed: ifallunbindersare
reboundwithvaluesoftherequiredtypes,thenthesubstitution isperformed,otherwiseadynamic
errorisraised.
Forinstance,theterm1hx,y|x+yi[x7→1,y7→2]reducesto1+2,whereasbothhx,y|x+yi[x7→1]
andhx:int|x+1i[x:int→int7→l y.y+1]reducetoerror.
Unbinding and rebinding are hierarchical, that is, the term t can contain arbitrarily nested unbound
terms, whose inside code can only be executed after a sequence of rebinds has been applied2. For
instance, tworebindsmustbeappliedtothetermhx|x+hx|xiiinordertogetaninteger:
hx|x+hx|xii[x7→1][x7→2] −→ (1+hx|xi)[x7→2]
−→ (1[x7→2])+(hx|xi[x7→2])
−→⋆ 1+2
∗ThisworkhasbeenpartiallysupportedbyMIURDISCO-Distribution,Interaction,Specification,CompositionforObject
Systems,andIPODS-InteractingProcessesinOpen-endedDistributedSystems.
1Intheexamplesweomittypeannotationswhentheyareirrelevant.
2SeetheConclusionformorecommentsonthischoice.
E.Pimentel,B.VenneriandJ.Wells(Eds.):Workshopon (cid:13)c Dezani,GianniniandZucca
IntersectionTypesandRelatedSystems2010(ITRS2010). Thisworkislicensedunderthe
EPTCS45,2011,pp.45–58,doi:10.4204/EPTCS.45.4 CreativeCommonsAttributionLicense.
46 Intersectiontypesforunbindandrebind
Correspondingly, typesaredecoratedwithlevels,andatermhastypet k ifitneedskrebindsinorder
toreducetoavalueoftypet . Withintersectiontypeswemodelthefactthatatermcanbeuseddifferently
incontextswhichprovideadifferentnumberkofunbinds. Forinstance,thetermhx|x+hx|xiiabove
has type int2∧code0, since it can be safely used in two ways: either in a context which provides two
rebinds, asshownabove,orasavalueoftypecode,as,e.g.,in:
(l y.y[x7→1][x7→2])hx|x+hx|xii
Ontheotherside,thetermhx|x+hx|xiidoesnothavetypeint1,sincebyapplying onlyonerebind
with[x7→1]wegettheterm1+hx|xiwhichisstuck.
The use of intersection types allows us to get soundness w.r.t. the call-by-value strategy. This issue
was not resolved by previous type systems [12, 13]where, for this reason, weonly considered the call-
by-namereduction strategy. Toseetheproblem,consider thefollowingexample.
Theterm
(l y.y[x7→2])(1+hx|xi)
is stuck in the call-by-value strategy, since the argument is not a value, hence should be ill typed, even
though the argument has type int1, which is a correct type for the argument of the function. By using
intersection types, this can beenforced by requiring arguments offunctions tohave value types, that is,
intersections where (at least) one of the conjuncts is a type of level 0. In this way, the above term is ill
typed. Notethatacall-by-name evaluation oftheabovetermgives
(l y.y[x7→2])(1+hx|xi) −→ (1+hx|xi)[x7→2]
−→ (1[x7→2])+(hx|xi[x7→2])
−→⋆ 1+2.
Instead, theterm (l y.y[x7→2])hx|1+xiiswelltyped, anditreduces asfollows inbothcall-by-value
andcall-by-name strategies:
(l y.y[x7→2])hx|1+xi −→ hx|1+xi[x7→2]
−→ 1+2.
It is interesting to note that this phenomenon is due to the possibility for operators (in our case for
+) of acting on arguments which are unbound terms. This design choice is quite natural in view of dis-
cussingopencode,asinMetaML[23]. Inpurel -calculusthereisnoclosedtermwhichconvergeswhen
evaluated by the lazy call-by-name strategy and is stuck when evaluated by the call-by-value strategy.
Instead there are closed terms, like (l x.l y.y)((l z.zz)(l z.zz)), which converge when evaluated by the
lazy call-by-name strategy and diverge when evaluated by the call-by-value strategy, and open terms,
like (l x.l y.y)z, which converge when evaluated by the lazy call-by-name strategy and are stuck when
evaluated bythecall-by-value strategy.3
Insummary,thecontribution ofthispaperisthefollowing. Wedefineatypesystemforthecalculus
of Dezani et al. [12, 13], where, differently from those papers, weomit types on the lambda-binders in
order to get the whole expressivity of the intersection type constructor [25]. Thetype system shows, in
ouropinion, aninteresting andnovelapplication ofintersection types. Indeed, they handle inauniform
waythethreefollowingissues.
• Functionsmaybeappliedtoarguments of(afinitesetof)different types.
• A term can be used differently in contexts providing different numbers of unbinds. Indeed, an
intersection type for a term includes a type of form t k if the term needs k rebinds in order to
reducetoavalueoftypet .
3NotethatfollowingPierce[18]weconsideronlyl -abstractionsasvalues,whileforPlotkin[19]alsovariablesarevalues.
Dezani,GianniniandZucca 47
• Most notably, the type system guarantees soundness for the call-by-value strategy, by requiring
that top-level terms, that is, terms which do not require unbinds to reduce to values, should have
valuetypes.
PaperStructure. InSection1weintroduce thesyntax andtheoperational semantics ofthelanguage.
In Section 2 we define the type system and prove its soundness in Section 3. In Section 4 we discuss
relatedandfurtherwork.
1 Calculus
Thesyntaxandreduction rulesofthecalculus aregiveninFigure1.
t ::= x|n|t +t |l x.t|t t |hG |ti|t[r]|error term
1 2 1 2
G ::= x :T ,...,x :T typecontext
1 1 m m
r ::= x :T 7→t ,...,x :T 7→t (typed)substitution
1 1 1 m m m
v ::= l x.t|hG |ti|n value
rv ::= x :T 7→v ,...,x :T 7→v valuesubstitution
1 1 1 m m m
E ::= []|E +t|n+E |E t|vE |t[r,x:T 7→E] evaluationcontext
s ::= x 7→v ,...,x 7→v (untyped)substitution
1 1 m m
Z
n1+n2−→n if n˜ =n˜1+ n˜2 (SUM)
(l x.t)v−→t{x7→v} (APP)
hG |ti[rv]−→t{subst(rv)|dom(G )} if G ⊆tenv(rv) (REBINDUNBINDYES)
hG |ti[rv]−→error if G 6⊆tenv(rv) (REBINDUNBINDNO)
n[rv]−→n (REBINDNUM)
(t1+t2)[rv]−→t1[rv]+t2[rv] (REBINDSUM)
(l x.t)[rv]−→l x.t[rv] (REBINDABS)
(t1t2)[rv]−→t1[rv]t2[rv] (REBINDAPP)
t[r][rv]−→t′[rv] if t[r]−→t′ (REBINDREBIND)
error[rv]−→error (REBINDERROR)
t−→t′ E 6=[] t−→error E 6=[]
(CTX) (CTXERROR)
E[t]−→E[t′] E[t]−→error
Figure1: Syntaxandreduction rules
Terms of the calculus are the l -calculus terms, the unbind and rebind constructs, and the dynamic
error. Moreover, weinclude integers withaddition to show how unbind and rebind behave on primitive
datatypes. UnbindersandrebindersareannotatedwithtypesT,whichwillbedescribedinthefollowing
section. Hereitisenough toassume thatthey include standard intandfunctional types. Typecontexts
andsubstitutions areassumedtobemaps,thatis,orderisimmaterialandvariables cannotappeartwice.
48 Intersectiontypesforunbindandrebind
Free variables and application of a substitution to a term are defined in Figure 2. Note that an
unbinder behaves like a l -binder: for instance, in a term of shape hx|ti, the unbinder x introduces a
local scope, that is, binds free occurrences ofx int. Hence, asubstitution for xis notpropagated inside
t. Moreover, a condition, which prevents capture of free variables similar to the l -abstraction case is
needed. For instance, the term (l y.hx|yi)(l z.x) reduces to hx|yi{y7→l z.x} which is stuck, i.e., it
doesnotreducetohx|l z.xi,whichwouldbewrong.
However, l -binders and unbinders behave differently w.r.t. a -equivalence. A l -binder can be re-
named,asusual,togetherwithallitsboundvariableoccurrences,whereasthisisnotsafeforanunbinder:
for instance, hx|x+1i[x7→2] is not equivalent to hy|y+1i[x7→2]. Only a global renaming, e.g.,
leading tohy|y+1i[y7→2],wouldbesafe.4
FV(x)={x}
FV(n)=0/
FV(t +t )=FV(t )∪FV(t )
1 2 1 2
FV(l x.t)=FV(t)\{x}
FV(t t )=FV(t )∪FV(t )
1 2 1 1
FV(hG |ti)=FV(t)\dom(G )
FV(t[r])=FV(t)∪FV(subst(r))
FV(x 7→t ,...,x 7→t )=S FV(t)
1 1 m m i∈1..m i
x{s }=vifs (x)=v
x{s }=xifx6∈dom(s )
n{s }=n
(t +t ){s }=t {s }+t {s }
1 2 1 2
(l x.t){s }=l x.t{s }ifx6∈FV(s )
\{x}
(t t ){s }=t {s }t {s }
1 2 1 2
hG |ti{s }=hG |t{s \dom(G )}iifdom(G )∩FV(s )=0/
t[x :T 7→t ,...,x :T 7→t ]{s }=t{s }[x :T 7→t {s },...,x :T 7→t {s }]
1 1 1 m m m 1 1 1 m m m
Figure2: Freevariablesandapplication ofsubstitution
Thecall-by-value operational semantics isdescribed bythe reduction rules and thedefinition of the
evaluation contextsE. Wedenotebyn˜ theintegerrepresented bytheconstantn,bytenv(r)andsubst(r)
thetypecontextandtheuntypedsubstitution, respectively, extractedfromatypedsubstitution r,bydom
the domain of amap, by s and s the substitutions obtained from s by restricting to or
|{x1,...,xn} \{x1,...,xn}
removingvariables inset{x ,...,x },respectively.
1 n
Rules for sum and application (of a lambda to a value) are standard. The (REBIND) rules determine
what happens when a rebind is applied to a term. There are two rules for the rebinding of an unbound
term. Rule (REBINDUNBINDYES)is applied when the unbound variables are all present (and of the required
types), in which case the associated values are substituted, otherwise rule (REBINDUNBINDNO)produces a
4Amoresophisticatedsolution[5]allowslocalrenamingofunbindersbya“precompilation”stepannotatingvariableswith
indexes, whichcanbea -renamed, butarenottakenintoaccountbytherebindingmechanism. Indeed, variableoccurrences
whichareunbinders,rebinders,orboundtoanunbinder,actuallyplaytheroleofnamesratherthanstandardvariables. Note
thatvariablesinarebinder,e.g.,xin[x7→2],arenotbindings,andxisneitherafree,noraboundvariable.SeetheConclusion
formorecommentsonthisdifference.
Dezani,GianniniandZucca 49
dynamicerror. ThisisformallyexpressedbythesideconditionG ⊆tenv(r). Notethatarebindappliedto
atermmaybestuckeventhoughthevariablesareallpresentandoftherighttype,whenthesubstitution
is not defined. This may be caused by the fact that when applied to an unbound term, a substitution
could cause capture of free variables (see the example earlier in this section). Rebinding a term which
isanumber orerror does not affect the term. Onsum, abstraction and application, the rebind issimply
propagated to subterms, and if a rebind is applied to a rebound term, (REBINDREBIND), the inner rebind is
applied first. The evaluation order is specified by rule (CTX)and the definition of contexts, E, that gives
thecall-by-valuestrategy. Finallyrule(CTXERROR)propagateserrors. Tomakeruleselectiondeterministic,
rules (CTX)and (CTXERROR)areapplicable only whenE 6=[]. Asusual −→⋆ isthereflexiveandtransitive
closure of−→.
When a rebind is applied, only variables which were explicitly specified as unbinders are replaced.
Forinstance, thetermhx|x+yi[x7→1,y7→2]reduces to1+yrather thanto1+2. Inother words, the
unbinding/rebinding mechanism isexplicitlycontrolled bytheprogrammer.
Lookingattheruleswecanseethatthereisnorulefortherebinding ofavariable. Indeed,itwillbe
resolved only whenthe variable issubstituted aseffect ofastandard application. Forinstance, the term
(l y.y[x7→2])hx|x+1ireducestohx|x+1i[x7→2].
Note that in rule (REBINDABS), the binder x of the l -abstraction does not interfere with the rebind,
even incase x∈dom(r). Indeed, rebind hasno effect onthe free occurrences ofx inthebody ofthel -
abstraction. Forinstance, (l x.x+hx|xi)[x7→1]2, which isa -equivalent to(l y.y+hx|xi)[x7→1]2,
reduces in some steps to 2+1. On the other hand, both l -binders and unbinders prevent a substitution
forthecorresponding variablefrombeingpropagated intheirscope,forinstance:
hx,y|x+l x.(x+y)+hx|x+yii[x7→2,y7→3]−→2+(l x.x+3)+hx|x+3i
Astandard(static)bindercanalsoaffectcodetobedynamicallyrebound,whenitbindsfreevariables
inasubstitution r,asshownbythefollowingexample:
(l x.l y.y[x7→x]+x)1hx|x+2i−→(l y.y[x7→1]+1)hx|x+2i
−→hx|x+2i[x7→1]+1−→1+2+1.
Notethatin[x7→x]thetwooccurrences ofxrefertodifferent variables. Indeed, thesecond isboundby
theexternallambdawhereasthefirstoneisarebinder.
2 Type system
Wehavethreekindsoftypes: primitivetypest ,valuetypesV,andtermtypesT;seeFigure3.
T ::= t k|T ∧T (k∈N) termtype
1 2
V ::= t 0|V∧T valuetype
t ::= int|code|T →T′ primitivetype
Figure3: Types
Primitivetypescharacterise theshapeofvalues. Inourcasewehaveintegers (int),functions (T →
T′),andcode,whichisthetypeofatermhG |ti,thatis,(possibly) opencode.
Termtypesareprimitivetypesdecoratedwithalevelkorintersectionoftypes. Ifatermhastypet k,
thenbyapplying k rebindoperators tothetermwegetavalueofprimitive typet . Weabbreviate atype
t 0 byt . Termshave theintersection typeT ∧T whentheyhavebothtypes T andT . Onintersection
1 2 1 2
50 Intersectiontypesforunbindandrebind
we have the usual congruence due to idempotence, commutativity, associativity, and distributivity over
arrowtype,definedinthefirstfourclausesofFigure4.
Valuetypescharacterise termsthatreduce tovalues, sotheyareintersections inwhich(atleast)one
of the conjuncts must beaprimitive type of level 0. Forinstance, the term hx:int|hy:int|x+yii
has type code0∧code1∧int2,since itiscode that applying one rebinding produces code that, inturn,
applying another rebinding produces an integer. The term h x : int|x + h y : int|y + 1 i i has type
code0∧int2 since it is code that applying one rebinding produces the term n+hy:int|y+1i, for
some n. Both code0∧code1∧int2 and code0∧int2 are value types, whereas int1, which is the
type of term n+hy:int|y+1i, is not a value type. Indeed, in order to produce an integer value the
term mustberebound (atleast)once. Thetyping ruleforapplication enforces therestriction thataterm
maybeapplied onlytotermsreducing tovalues, that isthe call-by-value strategy. Similarfor theterms
associated withvariables inasubstitution.
Let I ={1,...,m}. We write V t ki and V t ki to denote t k1∧···∧t km. Note that any type T
i∈I i i∈1..m i 1 m
is such that T =V t ki, for some t and k (i∈1..m). Given a type T =V t ki, with (T)⊕h we
i∈1..m i i i i∈1..m i
denotethetypeV t ki+h.
i∈1..m i
T ≡T∧T T ∧T ≡T ∧T T ∧(T ∧T )≡(T ∧T )∧T
1 2 2 1 1 2 3 1 2 3
(T →T )k∧(T →T )k ≡(T →T ∧T )k (T′→(T)⊕h)k+1≡(T′→(T)⊕(h+1))k
1 2 1 2
Figure4: Congruence ontypes
Figure 4 defines congruence on types. In addition to the standard properties of intersection, the
last clause says that the level of function types can be switched with the one of their results. That is,
unbinding andlambda-abstraction commute. Sorebinding maybeappliedtolambda-abstractions, since
reduction rule (REBINDABS) pushes rebinding inside. For instance, the terms hG |l x.t i and l x.h G |t i
maybeusedinterchangeably.
intk ≤intk+1 T ∧T ≤T
1 2 1
T ≤T T′ ≤T′ T ≤T′ T ≤T′
2 1 1 2 1 1 2 2
(T →T′)k ≤(T →T′)k T ∧T ≤T′∧T′
1 1 2 2 1 2 1 2
T ≤T T ≤T T ≡T
1 2 2 3 1 2
T ≤T T ≤T
1 3 1 2
Figure5: Subtyping ontypes
Subtyping, defined in Figure 5, expresses subsumption, that is, if a term has type T , then it can be
1
used also inacontext requiring atype T withT ≤T . Forinteger types it isjustified by thereduction
2 1 2
rule (REBINDNUM), since once we obtain an integer value any number of rebindings may be applied.5
For intersections, it is intersection elimination. The other rules are the standard extension of subtyping
5Notethatthegeneralisationofintk≤intk+1toTk≤Tk+1issoundbutuseless.
Dezani,GianniniandZucca 51
to function and intersection types, transitivity, and the fact that congruent types are in the subtyping
relation.
G ⊢t:T G ⊢t:T G ⊢t:T T ≤T′ G (x)=T
1 2
(T-INTER) G ⊢t:T ∧T (T-SUB) G ⊢t:T′ (T-VAR) G ⊢x:T
1 2
G ⊢t :intk G ⊢t :intk
1 2
(T-NUM) G ⊢n:int0 (T-SUM) G ⊢t +t :intk (T-ERROR) G ⊢error:T
1 2
G ,x:T ⊢t:T′ G ⊢t :(V →T)0 G ⊢t :V
1 2
(T-ABS) G ⊢l x.t:(T →T′)0 (T-APP) G ⊢t t :T
1 2
G ,G ′⊢t:T G ,G ′⊢t:T
(T-UNBIND-0) G ⊢hG ′|ti:code0 (T-UNBIND) G ⊢hG ′|ti:(T)⊕1
G ⊢t:(T)⊕1 G ⊢r:ok G ⊢t :V V ≤T (i∈1..m)
i i i i
(T-REBIND) G ⊢t[r]:T (T-REBINDING) G ⊢x :T 7→t ,...,x :T 7→t :ok
1 1 1 m m m
Figure6: Typingrules
Typing rules are defined in Figure 6. Wedenote by G ,G ′ the concatenation of the two type contexts
G andG ′ withdisjoint domains,whichturnsouttobeatypecontext(map)aswell.
Anumber hasthevaluetype int0. Withrule (T-SUB),however, itcanbegiven thetypeintk forany
k. Rule(T-SUM)requiresthatbothoperandsofasumhavethesametype,withrule(T-SUB)thetermcanbe
given as level the biggest level of the operands. Rule (T-ERROR)permits the use of error in any context.
Inrule (T-ABS)theinitiallevelofalambdaabstraction is0sincethetermisavalue. Withrule (T-SUB)we
maydecreasethelevelofthereturntypebyincreasing,bythesameamount,thelevelofthewholearrow
type. Thisisusefulsince, forexample,wecanderive
⊢l x.x+hy:int|y+hz:int|zii:(int→int1)1
byfirstderiving thetype(int→int2)0 fortheterm,andthenapplying (T-SUB). Therefore, wecangive
typetotherebinding oftheterm,byapplying rule (T-REBINDING)thatrequires thatthetermtoberebound
haslevelbiggerthan0,andwhoseresulting typeisdecreased byone. Forexample,
⊢(l x.x+hy:int|y+hz:int|zii)[y:int7→5]:(int→int1)0
which means that the term reduces to a lambda abstraction, i.e., to a value, which applied to an integer
needs one rebind in order to produce an integer or error. The rule (T-APP)assumes that the type of the
function be a level 0type. Thisis not a restriction, since using rule (T-SUB), if the term has any function
type it is possible to assign it a level 0 type. The type of the argument must be a value type. This
condition isjustifiedbytheexamplegivenintheintroduction.
The two rules for unbinds reflect the fact that code is both a value, and as such has type code0,
and also a term that needs one more rebinding than its body in order to produce a value. Taking the
intersection ofthetypesderivedforthesameunbind withthesetworuleswecanderiveavaluetypefor
0 1
the unbind and useit asargument ofan application. Forexample typing hy:int|yibycode ∧int
wecanderivetypeint0 fortheterm
52 Intersectiontypesforunbindandrebind
(l x.2+x[y: int7→3])hy:int|yi.
The present type system only takes into account the number of rebindings which are applied to a
term, whereas no check is performed on the name and the type of the variables to be rebound. This
checkisperformedatruntimebyrules(REBINDUNBINDYES)and(REBINDUNBINDNO). Inpapersintroducingthe
calculus [12, 13] wehave also provided an alternative type system (for the call-by-name calculus) such
thatthischeckisstaticallyperfomed, seetheConclusion formorecomments.
Note that terms which are stuck since application of substitution is undefined, such as the previous
example (l y.h x|y i)(l z.x), are ill typed. Indeed, in the typing rules for unbinding, unbinders are
required tobedisjoint fromouter binders, andthere isnoweakening rule. Hence, atype context forthe
exampleshouldsimultaneously includeatypeforxandnotincludeatypeforxinordertotypel z.xand
l y.hx|yi, respectively. For the same reason, a peculiarity of the given type system is that weakening
doesnothold,inspiteofthefactthatnonotionoflinearity isenforced.
3 Soundness of the type system
The type system is safe since types are preserved by reduction and a closed term with value type is
a value or error or can be reduced. In other words the system has both the subject reduction and the
progress properties. Notethatatermthatmaynotbeassigned avaluetypecanbestuck, asforexample
1+hx:int|xi,whichhastypeint1.
The proof of subject reduction (Theorem 5) is standard. We start with a lemma (Lemma 1) on the
propertiesoftheequivalenceandpre-orderrelationontypes,whichcanbeeasilyshownbyinductionon
their definitions. Then wegive anInversion Lemma(Lemma2), aSubstitution Lemma(Lemma3)and
a Context Lemma (Lemma 4). Lemmas 2 and 3 can be easily shown by induction on type derivations.
TheproofofLemma4isbystructural induction oncontexts.
Lemma1
1. IfVi∈I(Ti→Ti′)0≡(T →T′)0,thenTi≡T foralli∈I andVi∈ITi′≡T′.
2. IfV (T →T′)0≤T,thenthereareL,Tˆ ,Tˆ′,(l ∈L),suchthatT ≡V (Tˆ →Tˆ′)0,andforall
i∈I i i l l l∈L l l
l∈LthereisJ ⊆I with
l
• Tˆ ≤T forall j∈J,and
l j l
• V Tˆ′ ≤T′.
j∈Jl j l
Lemma2(Inversion Lemma)
1. IfG ⊢x:T,thenG (x)≤T.
2. IfG ⊢n:T,thenint0≤T.
3. IfG ⊢t +t :T,thenint0≤T andG ⊢t :T andG ⊢t :T.
1 2 1 2
4. IfG ⊢l x.t:T,thentherearem,T,T′(i∈1..m)suchthatT≡V (T →T′)0,andG ,x:T ⊢t:T′
i i i∈1..m i i i i
(i∈1..m).
5. IfG ⊢t t :T,thenthereisV suchthatG ⊢t :(V →T)0 andG ⊢t :V.
1 2 1 2
6. IfG ⊢hG ′|ti:V t ki,then
i∈1..m i
• G ,G ′⊢t:t ki−1 forallk >0,and
i i
• t =codeforallk =0.
i i
Dezani,GianniniandZucca 53
Whenm=1andk =0wealsohaveG ,G ′⊢t:T′,forsomeT′.
1
7. IfG ⊢t[r]:V t ki,thenG ⊢t:V t ki+1 andG ⊢r:ok.
i∈1..m i i∈1..m i
8. IfG ⊢x :T 7→t ,...,x :T 7→t :ok,thenthereareV ≤T fori∈1..msuchthatG ⊢t :V.
1 1 1 m m m i i i i
Proof Byinduction ontypingderivations. Weonlyconsider someinteresting cases.
ForPoint(4),ifthelastappliedruleis(T-SUB),thentheresultfollowsbyinductionfromLemma1(2).
ForthesamePointifthelastapplied ruleis (T-INTER),thenletG ⊢l x.t:T∧T′. Byinduction hypothesis
therearem,m′,T,T′,Tˆ ,Tˆ′ (i∈1..m, j∈1..m′)suchthat:
i j i j
• T ≡Vi∈1..m(Ti→Tˆi)0,
• G ,x:T ⊢t:Tˆ (i∈1..m),
i i
• T′≡V (T′ →Tˆ′)0,and
j∈1..m′ j j
• G ,x:T′ ⊢t:Tˆ′ (j∈1..m′).
j j
ThereforeT∧T′≡V (T →Tˆ )0∧V (T′ →Tˆ′)0.
i∈1..m i i j∈1..m′ j j
For Point (5) if the last applied rule is (T-INTER), then let G ⊢t1t2 :T1∧T2. By induction hypothesis
wehaveG ⊢t :V →T andG ⊢t :V,forsomeV,i=1,2. WederiveG ⊢t :(V →T )∧(V →T )
1 i i 2 i i 1 1 1 2 2
and G ⊢t2 :V1∧V2 by rule (T-INTER). Since (V1 →T1)∧(V2→T2)≤V1∧V2→T1∧T2, applying rule
(T-SUB)wegetG ⊢t1:V1∧V2→T1∧T2.
Lemma3(SubstitutionLemma) IfG ,x:T ⊢t:T′,andG ⊢v:T,thenG ⊢t{x7→v}:T′.
Lemma4(ContextLemma) LetG ⊢E[t]:T,then
• G ⊢t:T′ forsomeT′,and
• ifG ⊢t′:T′,thenG ⊢E[t′]:T,forallt′.
Theorem5(SubjectReduction) IfG ⊢t:T andt−→t′,thenG ⊢t′:T.
Proof Byinduction onreduction derivations. Weonlyconsider someinteresting cases.
Iftheapplied ruleis(APP),then
(l x.t)v−→t{x7→v}
From G ⊢ (l x.t)v : T by Lemma 2, case (5) we have that: there is V such that G ⊢ l x.t : (V → T)0
and G ⊢v:V. By Lemma 2, case (4) we have that there are m, T, T′ (i∈1..m) such that (V →T)0 ≡
i i
V (T →T′)0, and G ,x:T ⊢t:T′ (i∈1..m). From Lemma 1(1) we get T ≡V for all i∈1..m and
i∈1..m i i i i i
Vi∈1..mTi′≡T. Thenwecanderive G ,x:V ⊢t:T using rules (T-SUB)and (T-INTER). ByLemma3wecon-
cludethatG ⊢t{x7→v}:T.
Iftheapplied ruleis(REBINDUNBINDYES),then
hG ′|ti[rv]−→t{subst(rv)|dom(G ′)} G ′⊆tenv(rv)
Let rv = x :T 7→ v ,...,x :T 7→ v . Since G ′ ⊆ tenv(rv) we have that G ′ = x :T ,...,x :T .
|dom(G ′) 1 1 1 m m m 1 1 m m
FromG ⊢hG ′|ti[rv]:T byLemma2,case(7),wegetT =V t ki andG ⊢hG ′|ti:V t ki+1 and
i∈1..n i i∈1..n i
G ⊢rv:ok. FromLemma2,case(6),wehavethatG ,G ′⊢t:V t ki. Moreover,byLemma2,case(8),
i∈1..n i
andrule(T-SUB)wehavethatG ⊢rv:okimpliesthatG ⊢vi:Ti fori∈1..m. ApplyingmtimesLemma3,
wederiveG ⊢t{subst(rv)|dom(G ′)}:T.
54 Intersectiontypesforunbindandrebind
In order to show the Progress Theorem (Theorem 9), we start as usual with a Canonical Forms
Lemma(Lemma6). Thenwestatethestandardrelationbetweentypecontextsandfreevariables(Lemma
7),andlastlyweprovethatallclosedtermswhicharerebound termsalwaysreduce(Lemma8).
Lemma6(CanonicalForms)
1. If⊢v:int0,thenv=n.
2. If⊢v:code0,thenv=hG |ti.
3. If⊢v:(T →T′)0,thenv=l x.t.
Proof Bycaseanalysis ontheshapeofvalues.
Lemma7 IfG ⊢t:T,thenFV(t)⊆dom(G ).
Proof Byinduction ontypederivations.
Lemma8 Ift=t′[rv]forsomet′ andrv,andFV(t)=0/,thent−→t′′ forsomet′′.
Proof Let t = t′[rv]···[rv] for some t′, rv, ..., rv (n ≥ 1), where t′ is not a rebind. The proof is by
1 n 1 n
mathematical induction onn.
If n = 1, then one of the reduction rules is applicable to t′[rv]. Note that, if t′ = h G |t i, then rule
1 1
(REBINDUNBINDYES)isapplicableincaseG isasubsetofthetypeenvironmentassociatedwithr1v,otherwise
rule (REBINDUNBINDNO)isapplicable.
Lett=t′[rv]···[rv ]. IfFV(t′[rv]···[rv ])=0/,thenalsoFV(t′[rv]···[rv])=0/. Byinductionhypothesis
1 n+1 1 n+1 1 n
t′[r1v]···[rnv]−→t′′,thereforet′[r1v]···[rnv+1]−→t′′[rnv+1]withrule (REBINDREBIND).
Theorem9(Progress) If⊢t:V,theneithertisavalue,ort=error,ort−→t′ forsomet′.
Proof Byinduction onthederivationof⊢t:V withcaseanalysis onthelasttypingruleused.
Iftisnotavalueorerror,thenthelastappliedruleinthetypederivationcannotbe(T-NUM),(T-ERROR),
(T-ABS), (T-UNBIND-0), or (T-UNBIND). Moreover the typing environment for the expression is empty, hence
byLemma7thelastapplied rulecannotbe(T-VAR).
If the last applied rule is (T-SUB), note that T ≤V implies that T is a value type, and therefore the
theorem holdsbyinduction.
Ifthelastappliedruleis(T-APP),thent=t1t2,andtakingintoaccountthattheresultingtypemustbe
avaluetype:
⊢t :V′→V ⊢t :V′
1 2
⊢t t :V
1 2
Ift isnotavalueorerror,then,byinductionhypothesis,t −→t′. Sot t =E[t ]withE =[]t ,andby
1 1 1 1 2 1 2
rule(CTX),t1t2−→t1′ t2. Ift1iserror,wecanapplyrule(CONTERROR)withthesamecontext. Itt1isavalue
v, and t is not a value or error, then, by induction hypothesis, t −→t′. So t t =E[t ] with E =v[],
2 2 2 1 2 2
andbyrule(CTX),vt2−→vt2′. Ift2 iserror,wecanapplyrule(CONTERROR)withthesamecontext. Ifboth
t1 andt2 arevalues,thenbyLemma6,case(3),t1=l x.t′ and,therefore, wecanapplyrule (APP).
Ifthelastapplied ruleis (T-SUM),thent=t1+t2 andtaking into account thattheresulting type must
beavaluetype:
⊢t :int0 ⊢t :int0
1 2
⊢t +t :int0
1 2
