Principles of Programming Languages

Size: px

Start display at page:

Download "Principles of Programming Languages"

Georgia Townsend
5 years ago
Views:

1 Principles f Prgramming Languages Slides by Dana Fisman based n bk by Mira Balaban and lecuture ntes by Michael Elhadad Dana Fisman Lessn 16 Type Inference System 1

ptimized transfrmatin f the algrithm, relying n a mre cmpact data structure (resulting in less traversals f

2 Type Inference System In the previus lessn we intrduced a type inference algrithm fr the language L5, based n slving type equatins Tday we will see tw implementatins fr it: A literal applicatin f the algrithm An ptimized transfrmatin f the algrithm, relying n a mre cmpact data structure (resulting in less traversals f the prgram) Cde in L5-substitutin-adt.rkt L5-substitutin-adt-tests.rkt L5-tye-equatins.rkt L5-tye-equatins-tests.rkt

3 The Substitutin ADT A type substitutin s is a mapping frm a finite set f type variables t a finite set f type expressins s : TypeVars -> TypeExpr such that s(t) des nt refer t T. We define its ADT inductively as the disjint unin f tw disjint types: The empty substitutin Nn-empty substitutin sub( tvars: List(tvar), texp: List(Texp) )

4 The Substitutin ADT The functinal interface f the substitutin ADT includes: Value cnstructrs fr The empty substitutin Nn-empty substitutin sub( tvars, texp) Value cnstructr fr substitutin cmpsitin sub-cmbine( sub1, sub2) Bth sub and sub-cmbine return a nn-empty substitutin They als enfrce the key invariant f substitutin s(t) des nt refer t T This check is prefrmed by check-n-ccurrence! (tvar, texp) This prcess is called ccurrence check It is central t all unificatin based methds It is a cmputatinally expensive cmpnent f the algrithm

5 Occurrence Check The functin check-n-ccurrence! (tvar, texp) wrks as a standard AST traversal ;; Purpse: when attempting t bind tvar t te in a substitutin ;; check whether tvar ccurs in te. ;; Thrws errr if a circular reference is fund. ;; Signature: check-n-ccurrence!(tvar, te) ;; Type: [Tvar * Texp -> Symbl] ;; Pre-cnditins: Tvar is nt bund (define check-n-ccurrence! (lambda (tvar te) (letrec ((lp (lambda (te1) (cnd [(atmic-te? te1) #t] [(prc-te? te1) (fr-each lp (prc-te->param-tes te1)) (lp (prc-te->return-te te1)) 'prc-te-k] [(tvar? te1) (if (eq? (tvar->var te1) (tvar->var tvar)) (errr "Occurrence check errr - circular unificatin ~s ~s in ~s" tvar te exp) 'tvar-k)] [else (errr "Bad type expressin ~s ~s" te exp)])))) (lp te))))

6 Extending a type-substiutin An extended type-substitutin is defined (similarly t an extended env.) as a linked list f bindings (mapping vars t texp). When extending a type-substitutin, We first update the RHS f the current substitutin accrding t the new substitutin (if the variables in the new substitutin appear in the current) We check that there are n circularities

7 extend-sub ;; Purpse: Extend the substitutin sub with ;; an assignment f type-expressin texp t type variable var. ;; First update the current RHS in the substitutins which ;; refer t var with texp ;; Then add the pair (var, texp) t the updated substitutin. ;; Check that n-circular references result. ;; Signature: extend-sub(sub,var,texp) ;; Type: [Sub * TVar * TExp -> Sub] ;; Calls t make-sub d the ccur-check (define extend-sub (lambda (sub var texp) (if (empty-sub? sub) (make-sub (list var) (list texp)) (let ([vars (sub->variables sub)] [texps (sub->tes sub)] [new-sub (make-sub (list var) (list texp))]) (let ([updated-tes (map (lambda (sub-texp) (sub-apply new-sub sub-texp)) texps)]) (if (member var vars) (make-sub vars updated-tes) (make-sub (cns var vars) (cns texp updated-tes))))))))

8 sub-cmbine The prcedure sub-cmbine can nw be implemented by calling extend-sub n each binding ne by ne ;; Signature: sub-cmbine(sub1,sub2) ;; Purpse: Returns the cmpsitin f substitutins s.t.: ;; (sub-apply result te) === (sub-apply sub2 (sub-apply sub1 te)) ;; ;; Type: [Sub * Sub -> Sub] (define sub-cmbine (lambda (sub1 sub2) (cnd [(empty-sub? sub1) sub2] [(empty-sub? sub2) sub1] [else (letrec ((cmbine (lambda (sub vars tes) (if (empty? vars) sub (cmbine (extend-sub sub (car vars) (car tes)) (cdr vars) (cdr tes)))))) (cmbine sub1 (sub->variables sub2) (sub->tes sub2)))])))

9 The Equatin Mdule The type equatins mdule fllws the stages f the algrithm: 1. Rename bund variables in given expressin e. 2. Assign type variables t all sub-expressins f e. 3. Cnstruct type equatins. 4. Slve the equatins.

Assigning Type Variables The algrithm cllects all type variable assignments int a pl cnsisting f a list f pairs(exp, Tvar) fr every nde in the expressin AST.

10 Assigning Type Variables The algrithm cllects all type variable assignments int a pl cnsisting f a list f pairs(exp, Tvar) fr every nde in the expressin AST. Whenever a nde in the AST is reached, a type variable is allcated fr it as fllws: nde is nt var-ref nr var-decl: a fresh type-variable is allcated fr it, and the crrespnding binding is added t the pl nde is var-decl: If it cnsists f type anntatin (given by the prgrammer) the crrespnding binding is added t the pl O.w. a fresh type variable is allcated fr it and the crrespnding binding is added t the pl nde is var-ref: We assciated with it the already assigned variable

11 L5-expr->pl ;; Purpse: Traverse the abstract syntax tree L5-exp ;; and cllect all sub-expressins int a Pl f fresh type variables. ;; Type: [L5-exp -> Pl] ;; PstCnditin: every nde in the AST is mapped t a type variable ;; - while preserving scping relatins (define L5-exp->pl (lambda (exp) (letrec ((findvarlist (lambda (exp var-pl) (cnd [(null? exp) (make-empty-pl)] [(var-decl? exp) (extend-pl-var-decl exp var-pl)] [(cexp-atmic? exp) (extend-pl exp var-pl)] [(prc-exp? exp) (extend-pl exp (map-pl findvarlist (append (prc-exp->params exp) (prc-exp->bdy exp)) var-pl))] [(cexp-cmpsite? exp) (extend-pl exp (map-pl findvarlist (cexp-cmpsite->cmpnents exp) var-pl))] [else (errr 'findvarlist "Bad L5 exp ~s" exp)])))) (findvarlist exp (make-empty-pl)))))

12 Generating Equatins Next step: transfrm the current pl which is a list f bindings (expr, Tvar) int a list f equatins (lhs, rhs) Fr each nde, we invke make-equatin-frm-exp which cnstructs a type equatin accrding t the type f the nde fr instance if the nde is num-expr it derives the equatin Tnum-expr = Number if the nde is prc-expr it derives an equatin f the frm etc. Tprc-exp = [T1*.. * Tn -> Tr]

13 make-equatin-frm-exp (1) ;; Signature: make-equatin-frm-exp(exp, pl) ;; Purpse: Return a single equatin ;; Type: [Cexp * Pl -> Equatin] ;; Pre-cnditin: exp is a member f pl (define make-equatin-frm-exp (lambda (exp pl) (letrec ([get-tvar-f-exp (lambda (exp) (secnd (assc exp pl)))]) (cnd ;; The type f prcedure is (T1 *... * Tn -> Te) ;; where Te is the type f the last exp in the bdy f the prc. ;; and Ti is the type f each f the parameters. ;; N need t traverse the ther bdy expressins - they will be ;; traversed by the verall lp f pl->equatins [(prc-exp? exp) (let ([left (get-tvar-f-exp exp)] [right (make-prc-te (map var-decl->texp (prc-exp->params exp)) (get-tvar-f-exp (last (prc-exp->bdy exp))))]) (make-equatin left right))] ;; An applicatin must respect the type f its peratr ;; Type(Operatr) = [T1 *.. * Tn -> Te] ;; Type(Applicatin) = Te ;; e : (f Arg1... Argn) ===> Tf = [T1 *... * Tn -> Te] [(app-exp? exp) (let ([left (get-tvar-f-exp (app-exp->ratr exp))] ; Tf [right (make-prc-te (map get-tvar-f-exp (app-exp->rands exp)) (get-tvar-f-exp exp))]) ; Te (make-equatin left right))]...

14 make-equatin-frm-exp (2)... ;; The type f a number is Number [(num-exp? exp) (let ([left (get-tvar-f-exp exp)] [right (typef-num-exp exp)]) (make-equatin left right))] ;; The type f a blean is Blean [(bl-exp? exp) (let ([left (get-tvar-f-exp exp)] [right (typef-bl-exp exp)]) (make-equatin left right))] ;; The type f a primitive prcedure is given by the primitive. [(prim-p? exp) (let ([left (get-tvar-f-exp exp)] [right (typef-prim-p exp)]) (make-equatin left right))] ;; let-exp? ;; letrec-exp? [else (errr 'make-equatin "Bad expressin" exp)]))))

15 Slving the Equatins The slving algrithm we have seen in the previus lessn is implemented by prcedure slve (equatins, substitutin). Repeat Return 1. Apply 2. Bth atmic types? 3. One a variable? 4. Circular? 5. Bth cmpsite f same type? The returned substitutin sub satisfies the fllwing prperty: Fr any equatin eq = (lhs, rhs) in equatins lhs sub = rhs sub Thus, it essentially cmputes the unifier f all equatins!

16 Alg. fr Slving Equatins Input: Equatins - a set f type equatins Output: A type substitutin r FAIL Initializatin: substitutin := {} Repeat fr each equatin [te1 = te2] in Equatins : 1. Apply the current substitutin t the equatin (replace vars by their substituting expressins). te1 = te1 substitutin te2 = te2 substitutin equatin := [ te1 = te2 ] 2. Bth sides f the eq. te1 and te2 are atmic types? If te1 te2 utput FAIL. Else, d nthing. 3. One side f the eq. te1 r te2 is a variable? Say, te1 = T. Apply the substitutin t the equatin: equatin = [ T = te2 ] Add the equatin t the substitutin: substitutin := substitutin {T = te2 } 4. A circular substitutin ccurred? Output FAIL. 5. Bth side are cmpsite with the same type cnstructr? Split int equatins between crrespnding cmpnents and add t the set f Equatins Return substitutin

17 slve Repeat Return 1. Apply 2. Bth atmic types? 3. One a variable? 4. Circular? 5. Bth cmpsite f same type? ;; Signature: slve(equatins, substitutin) ;; Purpse: Slve the equatins, starting frm a given substitutin. ;; Returns the resulting substitutin, r errr, if nt slvable ;; Type: [List(Equatin)*Substitutin -> Substitutin] (define slve (lambda (equatins sub) (if (empty? equatins) sub (let ([eq (make-equatin (sub-apply sub (equatin->left (car equatins))) (sub-apply sub (equatin->right (car equatins))))])...

18 slve Repeat 1. Apply 2. Bth atmic types? 3. One a variable? Circular? (letrec ([slve-var-eq Return (lambda (var-part ther-part) (slve (cdr equatins) (sub-cmbine sub (make-sub (list var-part) (list ther-part)))))] [bth-sides-atmic? (lambda (eq) (and (atmic-te? (equatin->left eq)) (atmic-te? (equatin->right eq))))] [handle-bth-sides-atmic (lambda (eq) (if (equal-atmic-te? (equatin->left eq) (equatin->right eq)) (slve (cdr equatins) sub) (errr 'slve "equatin cntains unequal atmic types: ~e" eq)))]) Bth cmpsite f same type?

19 slve case #3 : ne is a var case #2 : bth atmic case #5 : cmpsite f same type Repeat 1. Apply 2. Bth atmic types? 3. One a variable? 4. Circular?... Return (cnd [(tvar? (equatin->left eq)) (slve-var-eq (equatin->left eq) (equatin->right eq))] [(tvar? (equatin->right eq)) (slve-var-eq (equatin->right eq) (equatin->left eq))] [(bth-sides-atmic? eq) (handle-bth-sides-atmic eq)] [(and (cmpsite-te? (equatin->left eq)) 5. Bth cmpsite f same type? (cmpsite-te? (equatin->right eq)) (unifyable-structure eq)) (slve (append (cdr equatins) (split-equatin eq)) sub)] [else (errr 'slve "equatin cntains incmpatible type expressin: ~s" eq)]))))))

20 Terminatin Argument Is the algrithm guaranteed t terminate? The bdy f the lp prcesses ne equatin in each step But sme steps add equatins. Repeat Return 1. Apply 2. Bth atmic types? 3. One a variable? 4. Circular? 5. Bth cmpsite f same type? Let s take a clse lk: Cases #2, #3: ne equatins is cnsumed, and substitutin becmes mre cmplex Case #4: algrithm halts Case #5: equatins are added. Suppse the depth f the AST fr the tw sides f the equatins is D. And that the number f children f the rt f the AST is n. Then we add n equatins, n expressins with AST f depth at mst D-1.

21 Terminatin Argument Let E be the set f Equatins. We assciate with E a measure (N,D) s.t. N is the number f equatins in E and D is the maximum height f the AST appearing in any equatin in E Repeat Return 1. Apply 2. Bth atmic types? 3. One a variable? 4. Circular? 5. Bth cmpsite f same type? If the current measure f E is (N,D) Then the measure f E after ne iteratin f the lp is either (N-1, D) r (N+n, D-1) When the current measure is (N,1) we cannt apply case #5 because nne f the equatins is cmpsite. Thus, the measure f the next step is necessarily (N-1,1). Hence, the measure will eventually reach (0,1) and the alg. will halt.

22 Putting all steps tgether Recall the verall stages f the algrithm: 1. Rename bund variables in given expressin e. 2. Assign type variables t all sub-expressins f e. 3. Cnstruct type equatins. 4. Slve the equatins.

23 infer-type ;; Signature: infer-type(exp) ;; Precnditin: assumes all variables names are distinct ;; Purpse: Infer the type f a L5 expressin using the equatins methd ;; Type: [Exp -> Texp] ;; Example: (unparse-texp (infer-type (parsel5 '(lambda (f x) (f (f x)))))) ;; ==> '((T_1 -> T_1) * T_1 -> T_1) (define infer-type (lambda (exp) (let* ([pl (L5-exp->pl exp)] [equatins (pl->equatins pl)] [sub (slve-equatins equatins)] [texp (secnd (assc exp pl))]) (if (member texp (sub->variables sub)) (sub->exp-f-var sub texp) texp))))

24 Verify-te-f-expr The generatin f fresh type variables makes it hard t verify t expressins are the same ;; Signature: verify-te-f-expr(expr te) ;; Purpse: (1) Map type-vars t sub expressins in expr (expr-tvars-list). ;; (2) Let tvar-f-expr be the type-var assciated with expr. ;; (3) Generate type equatins based n the expr-tvar map. ;; (4) Slve the equatins. ;; (5) Find the type-expressin assciated with tvar-f-expr. ;; (6) See if it is equivalent t the given expressin, expr. ;; (define verify-te-f-expr (lambda (exp tec) (let* ([expr (parsel5 exp)] [te (parse-texp tec)] [pl (L5-exp->pl expr)] [equatins (pl->equatins pl)] [slve-sub (slve-equatins equatins)] [tvar-f-expr (secnd (assc expr pl))] [type-f-expr (sub-apply slve-sub tvar-f-expr)]) (equivalent-tes? te type-f-expr))))

25 Type Inference with Direct Unificatin The described implementatin fllws the type equatin algrithm literally It explicitly manipulates substitutin data structures, and type equatins It cnstructs a map f expressins t type variables t ensure exhaustive traversal f the given prgram We nw present an ptimized versin, relying n a mdified representatin f the type variable data structure. The same alg. is implemented withut creating explicit data structure fr the pl, the equatins and the substitutins it is mre efficient memry-wise and requires less traversals f the data structures the peratins prefrmed eagerly in the first implementatin turn int lazy peratins

we update the bx value t Te We can nly update the bx value nce Technically we say the bx is empty if its value is #f

26 Type Variable with ne-way assignment The new type variable ADT assciates a bx with the given type variable Tv The bx initially has the value #f When we derive a cnstraint that this variable shuld be bund t a certain type expressin Te, we update the bx value t Te We can nly update the bx value nce Technically we say the bx is empty if its value is #f and nn-empty therwise S we can nly update the bx if it is empty Cde in L5-ast.rkt L5-typeinfernece.rkt L5-typeinfernece-test.rkt

Type Variable with ne-way assignment ;; Purpse: tvar value cnstructr ;; Type: [Symbl -> tvar] (define make-tvar (lambda (var) (list 'tvar var (bx #f)))) ;; Type: [Tvar * Tvar -> Blean] (define

27 Type Variable with ne-way assignment ;; Purpse: tvar value cnstructr ;; Type: [Symbl -> tvar] (define make-tvar (lambda (var) (list 'tvar var (bx #f)))) ;; Type: [Tvar * Tvar -> Blean] (define tvar-eq? (lambda (tvar1 tvar2) (eq? (tvar->var tvar1) (tvar->var tvar2)))) (define tvar->cntents (lambda (tvar) (unbx (third tvar)))) (define tvar-nn-empty? (lambda (tvar) (nt (eq? (tvar->cntents tvar) #f))))

28 Type Variable with ne-way assignment ;; Type: [TVar * Texp -> Vid] ;; Pre-cnditin: Tvar is empty ;; Pst-cnditin: Tvar is nn-empty (define tvar-set-cntents! (lambda (tvar val) (set-bx! (third tvar) val)))

Implicit graph We will ften set the value f a Tvar T1 t anther Tvar T2 Which can reference anther Tvar T3 and s n We thus have an implicit representatin f a graph f tvar references We need a methd t

29 Implicit graph We will ften set the value f a Tvar T1 t anther Tvar T2 Which can reference anther Tvar T3 and s n We thus have an implicit representatin f a graph f tvar references We need a methd t traverse this implicit graph ;; Purpse: find the reference f a tvar by fllwing ;; the chain f substitutins. ;; Signature: tvar-deref(tvar) ;; Type: [Texp -> Texp] (define tvar-deref (lambda (tvar) (cnd ([nt (tvar? tvar)) tvar] [(tvar-nn-empty? tvar) (tvar-deref (tvar->cntents tvar))] [else tvar])))

30 Optimized Type Inference Alg. Idea: wrks like the type checking alg. Recall that the type checking alg. assumes the expressin is fully anntated, and traverses the parse tree exhaustively fr each nde checking if its type is kay accrding t the nde type (prc-expr, if-expr, ) But when checking that tw types are equivalent Instead f insisting they are exactly the same Trying t make them the same, i.e. try t find a unifier Essentially we change check-equal-type t d unificatin rather than a shallw equality check

31 check-equal-type! ;; Purpse: Make type expressins equivalent by deriving a unifier ;; Thrws an errr if the types are nt unifiable. ;; Exp is nly passed fr dcumentatin purpses. ;; Type: [TE * TE * Exp -> Symbl] (define check-equal-type! (lambda (te1 te2 exp) (cnd [(and (tvar? te1) (tvar? te2)) (if (eq? (tvar->var te1) (tvar->var te2)) 'same-tvars-k (check-tvar-equal-type! te1 te2 exp))] [(tvar? te1) (check-tvar-equal-type! te1 te2 exp)] [(tvar? te2) (check-tvar-equal-type! te2 te1 exp)] [(and (atmic-te? te1) (atmic-te? te2)) (if (nt (eq? (atmic-te->name te1) (atmic-te->name te2))) (errr "Incmpatible atmic types " te1 te2 exp) 'atmic-k)] [(and (prc-te? te1) (prc-te? te2)) (let ([args-te1 (prc-te->param-tes te1)] [args-te2 (prc-te->param-tes te2)] [return-te1 (prc-te->return-te te1)] [return-te2 (prc-te->return-te te2)]) (if (nt (= (length args-te1) (length args-te2))) (errr "Wrng number f arguments " te1 te2 exp) 'args-number-k) (fr-each (lambda (rand1 rand2) (check-equal-type! rand1 rand2 exp)) args-te1 args-te2) (check-equal-type! return-te1 return-te2 exp) 'prc-tes-k)] [else (errr "Bad type expressin " te1 te2 exp)])))

32 check-tvar-equal-type! ;; Purpse: check that a type variable matches a type expressin ;; Exp is nly passed fr dcumentatin purpses. ;; Signature: check-tvar-equal-type(tvar, te, exp) ;; Type: [Tvar * Texp * Exp -> Symbl] ;; Pre-cnditins: Tvar is nt bund (define check-tvar-equal-type! (lambda (tvar te exp) (if (tvar-nn-empty? tvar) (check-equal-type! (tvar->cntents tvar) te exp) (let ([v1 (check-n-ccurrence! tvar te exp)]) (tvar-set-cntents! tvar te) 'tvar-set-k))))

33 check-n-ccurrence! ;; Purpse: when attempting t bind tvar t te ;; check whether tvar ccurs in te. ;; Thrws errr if a circular reference is fund. ;; Exp is nly passed fr dcumentatin purpses. ;; Signature: check-n-ccurrence!(tvar, te, exp) ;; Type: [Tvar * Texp * Exp -> Symbl] ;; Pre-cnditins: Tvar is nt bund (define check-n-ccurrence! (lambda (tvar te exp) (letrec ((lp (lambda (te1) (cnd [(atmic-te? te1) #t] [(prc-te? te1) (fr-each lp (prc-te->param-tes te1)) (lp (prc-te->return-te te1)) 'prc-te-k] [(tvar? te1) (if (eq? (tvar->var te1) (tvar->var tvar)) (errr "Occurrence check errr circular unificatin" tvar te exp) 'tvar-k)] [else (errr "Bad type expressin" te exp)])))) (lp te))))

34 Type Inference Alg. The ptimized type inference alg. is almst identical t the type checking alg. Except that check-type-equal prefrms unificatin instead f a shallw equality check In cmparisn t the first implementatin f type inference alg. we presented There is n explicit pl representatin Instead we pre-allcate type variables Applicatin ndes and prcedure ndes are nt explicitly anntated Instead when they are encuntered, the type equatin is eagerly slved by invking check-equal-type Substitutins are represented implicitly in the graph f tvar references

35 Summary We surveyed 2 implementatins f the Type Inference algrithm: An explicit representatin f type equatins and substitutins. An ptimized implementatin relying n ne-way type variables. Bth implementatins rely critically n the ccurcheck mechanism t avid creating circular substitutins.

36 Summary The type equatin algrithm perates in 3 steps: Map all sub-expressins in the prgram t type variables and stre this mapping in a pl data structure. Traverse the pl and apply the typing rules f the prgramming language t derive type equatins fr each applicatin and prcedure ndes in the AST f the prgram. Slve the resulting type equatins system using the unificatin algrithm which cmputes a substitutin fr the whle prgram. The direct unificatin implementatin f this algrithm relies n ne-way TVar data structure and exhaustive traversal f the AST. Each time an applicatin r prcedure ndes are met, the crrespnding type equatin is eagerly slved by assigning type variables t the crrespnding type expressins.

Principles of Programming Languages

Principles of Programming Languages Lesson 14 Type Checking Collaboration and Management Dana Fisman www.cs.bgu.ac.il/~ppl172 1 Type Checking We return to the issue of type safety we discussed informally,