Type Error Slicing What is a type error and how do you locate one?
|
|
|
- Neal Douglas
- 6 years ago
- Views:
Transcription
1 Type Error Slicing p.1/38 Type Error Slicing What is a type error and how do you locate one? Christian Haack DePaul University fpl.cs.depaul.edu/chaack Joe Wells Heriot-Watt University jbw
2 Type Error Slicing p.2/38 Overview Concepts. Examples. Algorithms. Completeness and Minimality. Conclusion.
3 Type Error Slicing p.3/38 Current Type Error Location Reporting Consider this Standard ML (SML) fragment: fn x => fn y => let val w = x + 1 in w::y end
4 Type Error Slicing p.3/38 Current Type Error Location Reporting Consider this Standard ML (SML) fragment: fn x => fn y => let val w = x + 1 in w::y end Suppose an error is made at the highlighted spot: fn x => fn y => let val w = y + 1 in w::y end
5 Type Error Slicing p.3/38 Current Type Error Location Reporting Consider this Standard ML (SML) fragment: fn x => fn y => let val w = x + 1 in w::y end Suppose an error is made at the highlighted spot: fn x => fn y => let val w = y + 1 in w::y end Type error reports using the W algorithm give this location: fn x => fn y => let val w = y + 1 in w::y end
6 Type Error Slicing p.3/38 Current Type Error Location Reporting Consider this Standard ML (SML) fragment: fn x => fn y => let val w = x + 1 in w::y end Suppose an error is made at the highlighted spot: fn x => fn y => let val w = y + 1 in w::y end Type error reports using the W algorithm give this location: fn x => fn y => let val w = y + 1 in w::y end Algorithm M algorithm gives this location: fn x => fn y => let val w = y + 1 in w::y end
7 Type Error Slicing p.4/38 Current Type Error Messages are Poor Most existing compilers make no effort to accurately locate type errors.
8 Type Error Slicing p.4/38 Current Type Error Messages are Poor Most existing compilers make no effort to accurately locate type errors. They typically report the location where the type checker discovered the error. But this is just one of the locations that jointly cause the error.
9 Type Error Slicing p.4/38 Current Type Error Messages are Poor Most existing compilers make no effort to accurately locate type errors. They typically report the location where the type checker discovered the error. But this is just one of the locations that jointly cause the error. As a result, many programmers find type error messages unhelpful, especially for higher-order languages with implicit typing.
10 Type Error Slicing p.4/38 Current Type Error Messages are Poor Most existing compilers make no effort to accurately locate type errors. They typically report the location where the type checker discovered the error. But this is just one of the locations that jointly cause the error. As a result, many programmers find type error messages unhelpful, especially for higher-order languages with implicit typing. For example, a comp.lang.ml posting: Even though I have some experience with SML/NJ and OCaml, I often find myself mired in type errors that take me forever to resolve.
11 Type Error Slicing p.5/38 Type Error Slices to the Rescue For each type error: Identify all program points that contribute to the error.
12 Type Error Slicing p.5/38 Type Error Slices to the Rescue For each type error: Identify all program points that contribute to the error. Display this set of program points or a program slice as the error location.
13 Type Error Slicing p.5/38 Type Error Slices to the Rescue For each type error: Identify all program points that contribute to the error. Display this set of program points or a program slice as the error location. The error slice should have the following properties:
14 Type Error Slicing p.5/38 Type Error Slices to the Rescue For each type error: Identify all program points that contribute to the error. Display this set of program points or a program slice as the error location. The error slice should have the following properties: Completeness. The error should be explainable independently, just by looking at the slice.
15 Type Error Slicing p.5/38 Type Error Slices to the Rescue For each type error: Identify all program points that contribute to the error. Display this set of program points or a program slice as the error location. The error slice should have the following properties: Completeness. The error should be explainable independently, just by looking at the slice. Minimality. Every proper subslice should be type-error-free.
16 Type Error Slicing p.6/38 Overview Concepts. Examples. Algorithms. Completeness and Minimality. Conclusion.
17 Example 1 val average = fn weight => fn list => let val iterator = fn (x,(sum,length)) => (sum + weight x, length+1) val (sum,length) = foldl iterator (0,0) list in sum div length end val find_best = fn weight => fn lists => let val average = average weight val iterator = fn (list,(best,max)) => let val avg_list = average list in if avg_list > max then (list,avg_list) else (best,max) end val (best,_) = foldl iterator (nil,0) lists in best end val find_best_simple = find_best 1 Type Error Slicing p.7/38
18 An Incomplete Error Location val average = fn weight => fn list => let val iterator = fn (x,(sum,length)) => (sum + weight x, length+1) val (sum,length) = foldl iterator (0,0) list in sum div length end val find_best = fn weight => fn lists => let val average = average weight val iterator = fn (list,(best,max)) => let val avg_list = average list in if avg_list > max then (list,avg_list) else (best,max) end val (best,_) = foldl iterator (nil,0) lists in best end val find_best_simple = find_best 1 Type Error Slicing p.8/38
19 Another Incomplete Error Location val average = fn weight => fn list => let val iterator = fn (x,(sum,length)) => (sum + weight x, length+1) val (sum,length) = foldl iterator (0,0) list in sum div length end val find_best = fn weight => fn lists => let val average = average weight val iterator = fn (list,(best,max)) => let val avg_list = average list in if avg_list > max then (list,avg_list) else (best,max) end val (best,_) = foldl iterator (nil,0) lists in best end val find_best_simple = find_best 1 Type Error Slicing p.9/38
20 A Complete and Minimal Error Location val average = fn weight => fn list => let val iterator = fn (x,(sum,length)) => (sum + weight val (sum,length) = foldl iterator (0,0) list in sum div length end x, length+1) val find_best = fn weight => fn lists => let val average = average weight val iterator = fn (list,(best,max)) => let val avg_list = average list in if avg_list > max then (list,avg_list) else (best,max) end val (best,_) = foldl iterator (nil,0) lists in best end val find_best_simple = find_best 1 Type Error Slicing p.10/38
21 Type Error Slice type constructor clash, endpoints: function vs. int (.. val average = fn weight => (.. weight (..)..).. val find best = fn weight => (.. average weight..).. find best 1..) Type Error Slicing p.11/38
22 A Possible Fix type constructor clash, endpoints: function vs. int (.. val average = fn weight => (.. weight * (..)..).. val find best = fn weight => (.. average weight..).. find best 1..) Type Error Slicing p.12/38
23 Another Possible Fix type constructor clash, endpoints: function vs. int (.. val average = fn weight => (.. weight (..)..).. val find best = fn weight => (.. average weight..).. find best (fn x => x)..) Type Error Slicing p.13/38
24 Yet Another Possible Fix type constructor clash, endpoints: function vs. int (.. val average = fn weight => (.. weight (..)..).. val find best = fn weight => (.. average (fn x => weight * x)..).. find best 1..) Type Error Slicing p.14/38
25 Example 2 val mapactl = fn iterator => fn (list,state) => let val iterator = fn (x,(list,state)) => let val (x,state) = iterator (x,state) in x, state) end in foldl iterator (nil,state) list end val iseven = fn n => n mod 2 = 0 val doubleodds = fn list => let val iterator = fn (n,inc) => if iseven n then ( n, inc ) else ( 2 * n, inc + n ) in mapactl iterator (list,0) end Type Error Slicing p.15/38
26 Overlapping Type Error Location #1 val mapactl = fn iterator => fn (list,state) => let val iterator = fn (x,(list,state)) => let val (x, state) = iterator (x,state) in x, state) end in foldl iterator (nil,state) list end val iseven = fn n => n mod 2 = 0 val doubleodds = fn list => let val iterator = fn (n,inc) => if iseven n then ( n, inc ) else ( 2 * n, inc + n ) in mapactl iterator (list,0) end Type Error Slicing p.16/38
27 Overlapping Type Error Location #2 val mapactl = fn iterator => fn (list,state) => let val iterator = fn (x,(list,state)) => let val (x, state) = iterator (x,state) in x, state) end in foldl iterator (nil,state) list end val iseven = fn n => n mod 2 = 0 val doubleodds = fn list => let val iterator = fn (n,inc) => if iseven n then ( n, inc ) else ( 2 * n, inc + n ) in mapactl iterator (list,0) end Type Error Slicing p.17/38
28 Fixing Overlapping Slice #1 type constructor clash, endpoints: int vs. list (.. val mapactl = fn iterator => (.. val (x,(..)) = iterator (..).. x..).. val iterator = fn (.. n..) => if (..) then ( n, (..) ) else (.. (..) + n..).. mapactl iterator..) Type Error Slicing p.18/38
29 Fixing Overlapping Slice #1 type constructor clash, endpoints: int vs. list (.. val mapactl = fn iterator => (.. val (x,(..)) = iterator (..).. [ x ]..).. val iterator = fn (.. n..) => if (..) then ( n, (..) ) else (.. (..) + n..).. mapactl iterator..) Type Error Slicing p.19/38
30 Fixing Overlapping Slice #1 type constructor clash, endpoints: int vs. list (.. val mapactl = fn iterator => (.. val (x,(..)) = iterator (..).. x..).. val iterator = fn (.. n..) => if (..) then ( [ n ], (..) ) else (.. (..) + n..).. mapactl iterator..) Type Error Slicing p.20/38
31 Fixing Overlapping Type Errors In many cases, it is likely that the program must be fixed in the overlap. So perhaps the overlap should be presented in a different color. Type Error Slicing p.21/38
32 Fixing Overlapping Type Errors In many cases, it is likely that the program must be fixed in the overlap. So perhaps the overlap should be presented in a different color. The rationale is that a single programming mistake can cause several type incompatibilities in other locations. Type Error Slicing p.21/38
33 Fixing Overlapping Type Errors In many cases, it is likely that the program must be fixed in the overlap. So perhaps the overlap should be presented in a different color. The rationale is that a single programming mistake can cause several type incompatibilities in other locations. However, there are cases where this does not hold. For example, when the programmer starts changing a representation and has not finished. Type Error Slicing p.21/38
34 Overview Concepts. Examples. Algorithms. Step 1: Associate a set of type constraints with each program point. Step 2: Find minimal unsolvable sets of constraints. Step 3: Compute slice representations. Completeness and Minimality. Conclusion. Type Error Slicing p.22/38
35 Avoiding Hindley/Milner Type System No type schemes. (Polymorphism through universal types. System W ) Type Error Slicing p.23/38
36 Avoiding Hindley/Milner Type System No type schemes. (Polymorphism through universal types. System W ) Instead, enumerate all use-types of free variables. (Polymorphism through intersection types. System T ) Type Error Slicing p.23/38
37 Avoiding Hindley/Milner Type System No type schemes. (Polymorphism through universal types. System W ) Instead, enumerate all use-types of free variables. (Polymorphism through intersection types. System T ) For SML s let-polymorphism, System W and System T permit the same well-typed closed terms. Type Error Slicing p.23/38
38 Avoiding Hindley/Milner Type System No type schemes. (Polymorphism through universal types. System W ) Instead, enumerate all use-types of free variables. (Polymorphism through intersection types. System T ) For SML s let-polymorphism, System W and System T permit the same well-typed closed terms. But the type inference algorithms differ. Algorithm T is more convenient for accurately tracking error locations. Type Error Slicing p.23/38
39 Generating Type Constraints M Γ, ty, C C is a set of labeled type constraints, ty 1 = l = ty 2 Type Error Slicing p.24/38
40 Generating Type Constraints M Γ, ty, C C is a set of labeled type constraints, ty 1 = l = ty 2 Spec: If (M Γ, ty, C ) and s is a solution of C, then s(γ), s(ty) is a principal typing of M. The labels are needed so that unification can track which program location caused each constraint. Type Error Slicing p.24/38
41 Generating Type Constraints For each subexpression, generate a fresh type variable that represents the type of this subexpression. Type Error Slicing p.25/38
42 Generating Type Constraints For each subexpression, generate a fresh type variable that represents the type of this subexpression. M Γ[x S], ty, C ; (λx k.m ) l Γ[x {}],, C new C where C new = Type Error Slicing p.25/38
43 Generating Type Constraints For each subexpression, generate a fresh type variable that represents the type of this subexpression. M Γ[x S], ty, C ; a l fresh (λx k.m ) l Γ[x {}], a l, C new C where C new = Type Error Slicing p.25/38
44 Generating Type Constraints For each subexpression, generate a fresh type variable that represents the type of this subexpression. Use type constraints to relate this type variable to the types of its children, and the types of the children to each other. M Γ[x S], ty, C ; a l fresh (λx k.m ) l Γ[x {}], a l, C new C where C new = Type Error Slicing p.25/38
45 Generating Type Constraints For each subexpression, generate a fresh type variable that represents the type of this subexpression. Use type constraints to relate this type variable to the types of its children, and the types of the children to each other. M Γ[x S], ty, C ; a k, a l fresh (λx k.m ) l Γ[x {}], a l, C new C where C new = {a k ty = l a l } Type Error Slicing p.25/38
46 Generating Type Constraints For each subexpression, generate a fresh type variable that represents the type of this subexpression. Use type constraints to relate this type variable to the types of its children, and the types of the children to each other. M Γ[x S], ty, C ; a k, a l fresh (λx k.m ) l Γ[x {}], a l, C new C where C new = {a k ty = l a l } {a k = k ty S ty S S} Type Error Slicing p.25/38
47 Overview Concepts. Examples. Algorithms. Step 1: Associate a set of type constraints with each program point. Step 2: Find minimal unsolvable sets of constraints. Step 3: Compute slice representations. Completeness and Minimality. Conclusion. Type Error Slicing p.26/38
48 Finding a Small Error Rewrite-based unification where, in addition, the (labels of) constraints that were used in a derivation are recorded. History-recording unification Type Error Slicing p.27/38
49 Finding a Small Error Rewrite-based unification where, in addition, the (labels of) constraints that were used in a derivation are recorded. History-recording unification { Success(σ) if C is solvable unify(c) = Error(L) otherwise where L is set of program point labels, σ type substitution Type Error Slicing p.27/38
50 Finding a Small Error Rewrite-based unification where, in addition, the (labels of) constraints that were used in a derivation are recorded. History-recording unification { Success(σ) if C is solvable unify(c) = Error(L) otherwise where L is set of program point labels, σ type substitution If unify(c) = Error(L), then: Π L (C) is unsolvable,... Type Error Slicing p.27/38
51 Finding a Small Error Rewrite-based unification where, in addition, the (labels of) constraints that were used in a derivation are recorded. History-recording unification { Success(σ) if C is solvable unify(c) = Error(L) otherwise where L is set of program point labels, σ type substitution If unify(c) = Error(L), then: Π L (C) is unsolvable, but not necessarily minimally unsolvable. Type Error Slicing p.27/38
52 Finding a Small Error Rewrite-based unification where, in addition, the (labels of) constraints that were used in a derivation are recorded. History-recording unification { Success(σ) if C is solvable unify(c) = Error(L) otherwise where L is set of program point labels, σ type substitution If unify(c) = Error(L), then: Π L (C) is unsolvable, but not necessarily minimally unsolvable. In our experience, it is usually small (close to minimal). Type Error Slicing p.27/38
53 Finding Minimal Errors Minimizing a small error: Given a small error of size n, one can minimize it by running history-recording unification at most n times on subsets of the small error. Type Error Slicing p.28/38
54 Finding Minimal Errors Minimizing a small error: Given a small error of size n, one can minimize it by running history-recording unification at most n times on subsets of the small error. Finding several small errors: In the worst case, the number of minimal errors grows exponentially in the size of the program. Type Error Slicing p.28/38
55 Finding Minimal Errors Minimizing a small error: Given a small error of size n, one can minimize it by running history-recording unification at most n times on subsets of the small error. Finding several small errors: In the worst case, the number of minimal errors grows exponentially in the size of the program. We don t know how to enumerate all minimal errors in a realistic time, even if the number of minimal errors is not large. Type Error Slicing p.28/38
56 Finding Minimal Errors Minimizing a small error: Given a small error of size n, one can minimize it by running history-recording unification at most n times on subsets of the small error. Finding several small errors: In the worst case, the number of minimal errors grows exponentially in the size of the program. We don t know how to enumerate all minimal errors in a realistic time, even if the number of minimal errors is not large. We have a simple procedure that finds a few different small errors fast, and then gives up. It runs unification several times on large constraint sets. Type Error Slicing p.28/38
57 Finding Minimal Errors, Summary We know how to find several, but not always all, minimal errors in a reasonably efficient way, by repeatedly using a history-recording unification algorithm. Type Error Slicing p.29/38
58 Finding Minimal Errors, Summary We know how to find several, but not always all, minimal errors in a reasonably efficient way, by repeatedly using a history-recording unification algorithm. There are probably more efficient (but also more complicated) algorithms using unification graphs (Port). Type Error Slicing p.29/38
59 Finding Minimal Errors, Summary We know how to find several, but not always all, minimal errors in a reasonably efficient way, by repeatedly using a history-recording unification algorithm. There are probably more efficient (but also more complicated) algorithms using unification graphs (Port). In the worst case, enumerating all minimal errors is infeasible, because there can be an exponential number of them. Type Error Slicing p.29/38
60 Finding Minimal Errors, Summary We know how to find several, but not always all, minimal errors in a reasonably efficient way, by repeatedly using a history-recording unification algorithm. There are probably more efficient (but also more complicated) algorithms using unification graphs (Port). In the worst case, enumerating all minimal errors is infeasible, because there can be an exponential number of them. SML type inference is worst-case DEXPTIME-complete, but in practice behaves almost linearly, so similarly we hope that this behaves reasonably in practice. Anyway, it is not necessary to enumerate all type error slices. Type Error Slicing p.29/38
61 Overview Concepts. Examples. Algorithms. Step 1: Associate a set of type constraints with each program point. Step 2: Find minimal unsolvable sets of constraints. Step 3: Compute slice representations. Completeness and Minimality. Conclusion. Type Error Slicing p.30/38
62 Computing Slice Representation Extend expression syntax class by: sl Slice ::=... dots(sl 1,..., sl k )... Type Error Slicing p.31/38
63 Computing Slice Representation Extend expression syntax class by: sl Slice ::=... dots(sl 1,..., sl k )... For example: λx. dots( x dots(), x + dots() ) Type Error Slicing p.31/38
64 Computing Slice Representation Extend expression syntax class by: sl Slice ::=... dots(sl 1,..., sl k )... For example: λx. dots( x dots(), x + dots() ) Textual presentation: fn x => (.. x (..).. x + (..)..) Type Error Slicing p.31/38
65 Computing Slice Representation Extend expression syntax class by: sl Slice ::=... dots(sl 1,..., sl k )... For example: λx. dots( x dots(), x + dots() ) Textual presentation: fn x => (.. x (..).. x + (..)..) slice : LabelSet Exp Slice slice(l, M ) replaces all syntax nodes of M that are not contained in L by dots-nodes. Type Error Slicing p.31/38
66 TypeErrorSlicing = Algorithms, Summary Slice o FindMinErrors o GenerateConstraints Type Error Slicing p.32/38
67 Overview Concepts. Examples. Algorithms. Completeness and Minimality. Conclusion. Type Error Slicing p.33/38
68 Completeness Additional typing rule for slices: Γ sl i : ty i for all i in {1,..., k} Γ dots(sl 1,..., sl k ) : ty Type Error Slicing p.34/38
69 Completeness Additional typing rule for slices: Γ sl i : ty i for all i in {1,..., k} Γ dots(sl 1,..., sl k ) : ty Theorem (Completeness). A program slice that is returned by TypeErrorSlicing has a type error (i.e. is not typable). Type Error Slicing p.34/38
70 Minimality Define subslice ordering on slices: sl 1 sl 2 iff sl 1 is obtained from sl 2 by replacing additional non-dots-nodes by dots-nodes. Type Error Slicing p.35/38
71 Minimality Define subslice ordering on slices: sl 1 sl 2 iff sl 1 is obtained from sl 2 by replacing additional non-dots-nodes by dots-nodes. Theorem (Minimality). Every proper subslice of a slice sl returned by TypeErrorSlicing has no type error (i.e. is typable), Type Error Slicing p.35/38
72 Minimality Define subslice ordering on slices: sl 1 sl 2 iff sl 1 is obtained from sl 2 by replacing additional non-dots-nodes by dots-nodes. Theorem (Minimality). Every proper subslice of a slice sl returned by TypeErrorSlicing has no type error (i.e. is typable), provided all bound variables of sl are distinct. Type Error Slicing p.35/38
73 Overview Concepts. Examples. Algorithms. Completeness and Minimality. Conclusion. Type Error Slicing p.36/38
74 Our Contributions An explanation of how to represent type error locations as program slices. Type Error Slicing p.37/38
75 Our Contributions An explanation of how to represent type error locations as program slices. A formal characterization of when a slice is a complete and minimal representation of a type error. Type Error Slicing p.37/38
76 Our Contributions An explanation of how to represent type error locations as program slices. A formal characterization of when a slice is a complete and minimal representation of a type error. Simple algorithms for finding complete and minimal type error slices. Type Error Slicing p.37/38
77 Our Contributions An explanation of how to represent type error locations as program slices. A formal characterization of when a slice is a complete and minimal representation of a type error. Simple algorithms for finding complete and minimal type error slices. Proofs that our algorithms yield minimal and complete slices. Type Error Slicing p.37/38
78 Our Contributions An explanation of how to represent type error locations as program slices. A formal characterization of when a slice is a complete and minimal representation of a type error. Simple algorithms for finding complete and minimal type error slices. Proofs that our algorithms yield minimal and complete slices. A demonstration implementation available via our web page at compositional-analysis/type-error-slicing/ slicing.cgi. Type Error Slicing p.37/38
79 Directly inspirational: Related Work Wand: Locating Sources of Type Errors Dinesh and Tip: Type error slicing for languages with explicit type annotations Yang, Michaelson, Trinder, (Wells): UAE algorithm Type Error Slicing p.38/38
80 Directly inspirational: Related Work Wand: Locating Sources of Type Errors Dinesh and Tip: Type error slicing for languages with explicit type annotations Yang, Michaelson, Trinder, (Wells): UAE algorithm Recent and similar in spirit: Chopella and Haynes (Indiana, 1995, 2002) Heeren et al. (Utrecht, 2002) Sulzmann et al.: Chameleon type debugger. Type Error Slicing p.38/38
81 Directly inspirational: Related Work Wand: Locating Sources of Type Errors Dinesh and Tip: Type error slicing for languages with explicit type annotations Yang, Michaelson, Trinder, (Wells): UAE algorithm Recent and similar in spirit: Chopella and Haynes (Indiana, 1995, 2002) Heeren et al. (Utrecht, 2002) Sulzmann et al.: Chameleon type debugger. Other work on type errors: Bernstein and Stark, Duggan and Bent, McAdam, Chitil, Flanagan et al. (MrSpidey), etc. Type Error Slicing p.38/38
82 Extend to full SML. Future Work Type Error Slicing p.39/38
83 Extend to full SML. Future Work Type annotations including module signatures. Type Error Slicing p.39/38
84 Future Work Extend to full SML. Type annotations including module signatures. Equality types and overloading. Type Error Slicing p.39/38
85 Future Work Extend to full SML. Type annotations including module signatures. Equality types and overloading.... Type Error Slicing p.39/38
86 Future Work Extend to full SML. Type annotations including module signatures. Equality types and overloading.... Add features for interactive debugging. Type Error Slicing p.39/38
87 Future Work Extend to full SML. Type annotations including module signatures. Equality types and overloading.... Add features for interactive debugging. Interactive navigation through location sets. Type Error Slicing p.39/38
88 Extend to full SML. Future Work Type annotations including module signatures. Equality types and overloading.... Add features for interactive debugging. Interactive navigation through location sets. Animation/rewriting of error slices to help explain them. Type Error Slicing p.39/38
89 Extend to full SML. Future Work Type annotations including module signatures. Equality types and overloading.... Add features for interactive debugging. Interactive navigation through location sets. Animation/rewriting of error slices to help explain them. More efficient and more compositional algorithms. Type Error Slicing p.39/38
90 Extend to full SML. Future Work Type annotations including module signatures. Equality types and overloading.... Add features for interactive debugging. Interactive navigation through location sets. Animation/rewriting of error slices to help explain them. More efficient and more compositional algorithms. Handle object-oriented languages (both class-based and object-based). Type Error Slicing p.39/38
Type Error Slicing in Implicitly Typed Higher-Order Languages
Type Error Slicing in Implicitly Typed Higher-Order Languages Christian Haack and J. B. Wells Heriot-Watt University http://www.cee.hw.ac.uk/ultra/ Abstract. Previous methods have generally identified
ML Type Inference and Unification. Arlen Cox
ML Type Inference and Unification Arlen Cox Research Goals Easy to use, high performance parallel programming Primary contributions in backend and runtime Need a front end to target backend ML offers ease
Programming Languages
CSE 230: Winter 2008 Principles of Programming Languages Ocaml/HW #3 Q-A Session Push deadline = Mar 10 Session Mon 3pm? Lecture 15: Type Systems Ranjit Jhala UC San Diego Why Typed Languages? Development
Type Checking and Type Inference
Type Checking and Type Inference Principles of Programming Languages CSE 307 1 Types in Programming Languages 2 Static Type Checking 3 Polymorphic Type Inference Version: 1.8 17:20:56 2014/08/25 Compiled
Visual Type Inference
Visual Type Inference Martin Erwig School of EECS Oregon State University Corvallis, OR 97331, USA erwig@eecs.oregonstate.edu January 12, 2005 Abstract We describe a type-inference algorithm that is based
Chapter 22: Type Reconstruction (Type Inference)
Chapter 22: Type Reconstruction (Type Inference) Calculating a Principal Type for a Term Constraint based Typing Unification and Principle Types Extension with let-polymorphism Type Variables and Type
Chapter 13: Reference. Why reference Typing Evaluation Store Typings Safety Notes
Chapter 13: Reference Why reference Typing Evaluation Store Typings Safety Notes References Computational Effects Also known as side effects. A function or expression is said to have a side effect if,
COMPUTER SCIENCE TRIPOS
CST.2011.3.1 COMPUTER SCIENCE TRIPOS Part IB Monday 6 June 2011 1.30 to 4.30 COMPUTER SCIENCE Paper 3 Answer five questions. Submit the answers in five separate bundles, each with its own cover sheet.
Types and Type Inference
CS 242 2012 Types and Type Inference Notes modified from John Mitchell and Kathleen Fisher Reading: Concepts in Programming Languages, Revised Chapter 6 - handout on Web!! Outline General discussion of
Simply-Typed Lambda Calculus
#1 Simply-Typed Lambda Calculus #2 Back to School What is operational semantics? When would you use contextual (small-step) semantics? What is denotational semantics? What is axiomatic semantics? What
Tracing Ambiguity in GADT Type Inference
Tracing Ambiguity in GADT Type Inference ML Workshop 2012, Copenhagen Jacques Garrigue & Didier Rémy Nagoya University / INRIA Garrigue & Rémy Tracing ambiguity 1 Generalized Algebraic Datatypes Algebraic
λ calculus is inconsistent
Content Rough timeline COMP 4161 NICTA Advanced Course Advanced Topics in Software Verification Gerwin Klein, June Andronick, Toby Murray λ Intro & motivation, getting started [1] Foundations & Principles
CSE505, Fall 2012, Midterm Examination October 30, 2012
CSE505, Fall 2012, Midterm Examination October 30, 2012 Rules: The exam is closed-book, closed-notes, except for one side of one 8.5x11in piece of paper. Please stop promptly at Noon. You can rip apart
Lecture #23: Conversion and Type Inference
Lecture #23: Conversion and Type Inference Administrivia. Due date for Project #2 moved to midnight tonight. Midterm mean 20, median 21 (my expectation: 17.5). Last modified: Fri Oct 20 10:46:40 2006 CS164:
How do people check polymorphic types?
In A.F. Blackwell & E. Bilotta (Eds). Proc. PPIG 12 Pages 67-80 How do people check polymorphic types? Yang Jun, Greg Michaelson and Phil Trinder Department of Computing and Electrical Engineering Heriot-Watt
Goal. CS152: Programming Languages. Lecture 15 Parametric Polymorphism. What the Library Likes. What The Client Likes. Start simpler.
Goal Understand what this interface means and why it matters: CS152: Programming Languages Lecture 15 Parametric Polymorphism Dan Grossman Spring 2011 type a mylist; val mt_list : a mylist val cons : a
Conversion vs. Subtyping. Lecture #23: Conversion and Type Inference. Integer Conversions. Conversions: Implicit vs. Explicit. Object x = "Hello";
Lecture #23: Conversion and Type Inference Administrivia. Due date for Project #2 moved to midnight tonight. Midterm mean 20, median 21 (my expectation: 17.5). In Java, this is legal: Object x = "Hello";
Type Systems Winter Semester 2006
Type Systems Winter Semester 2006 Week 9 December 13 December 13, 2006 - version 1.0 Plan PREVIOUSLY: unit, sequencing, let, pairs, sums TODAY: 1. recursion 2. state 3.??? NEXT: exceptions? NEXT: polymorphic
Lambda Calculus and Type Inference
Lambda Calculus and Type Inference Björn Lisper Dept. of Computer Science and Engineering Mälardalen University bjorn.lisper@mdh.se http://www.idt.mdh.se/ blr/ August 17, 2007 Lambda Calculus and Type
Harvard School of Engineering and Applied Sciences Computer Science 152
Harvard School of Engineering and Applied Sciences Computer Science 152 Lecture 17 Tuesday, March 30, 2010 1 Polymorph means many forms. Polymorphism is the ability of code to be used on values of different
An Approach to Completing Variable Names for Implicitly Typed Functional Languages
An Approach to Completing Variable Names for Implicitly Typed Functional Languages Takumi Goto Isao Sasano Shibaura Institute of Technology Tokyo, Japan {m110057, sasano}@sic.shibaura-it.ac.jp Abstract
Type Processing by Constraint Reasoning
, Martin Sulzmann, Jeremy Wazny 8th November 2006 Chameleon Chameleon is Haskell-style language treats type problems using constraints gives expressive error messages has a programmable type system Developers:
Simple Unification-based Type Inference for GADTs
Simple Unification-based Type Inference for GADTs Stephanie Weirich University of Pennsylvania joint work with Dimitrios Vytiniotis, Simon Peyton Jones and Geoffrey Washburn Overview Goal: Add GADTs to
CS558 Programming Languages
CS558 Programming Languages Fall 2017 Lecture 7b Andrew Tolmach Portland State University 1994-2017 Type Inference Some statically typed languages, like ML (and to a lesser extent Scala), offer alternative
Agenda. CS301 Session 11. Common type constructors. Things we could add to Impcore. Discussion: midterm exam - take-home or inclass?
Agenda CS301 Session 11 Discussion: midterm exam - take-home or inclass? Interlude: common type constructors Type soundness 1 2 Things we could add to Impcore Common type constructors Array is a type constructor,
Hard deadline: 3/28/15 1:00pm. Using software development tools like source control. Understanding the environment model and type inference.
CS 3110 Spring 2015 Problem Set 3 Version 0 (last modified March 12, 2015) Soft deadline: 3/26/15 11:59pm Hard deadline: 3/28/15 1:00pm Overview In this assignment you will implement several functions
CS558 Programming Languages
CS558 Programming Languages Winter 2018 Lecture 7b Andrew Tolmach Portland State University 1994-2018 Dynamic Type Checking Static type checking offers the great advantage of catching errors early And
TYPE INFERENCE. François Pottier. The Programming Languages Mentoring ICFP August 30, 2015
TYPE INFERENCE François Pottier The Programming Languages Mentoring Workshop @ ICFP August 30, 2015 What is type inference? What is the type of this OCaml function? let f verbose msg = if verbose then
todo ML-TID A Type Inference Debugger for ML in Education
todo ML-TID A Type Inference Debugger for ML in Education Ben Thorner University of Cambridge ben.thorner@cl.cam.ac.uk Kathryn Gray University of Cambridge kathryn.gray@cl.cam.ac.uk Abstract Student programmers
CSCI-GA Scripting Languages
CSCI-GA.3033.003 Scripting Languages 12/02/2013 OCaml 1 Acknowledgement The material on these slides is based on notes provided by Dexter Kozen. 2 About OCaml A functional programming language All computation
CS558 Programming Languages
CS558 Programming Languages Winter 2017 Lecture 7b Andrew Tolmach Portland State University 1994-2017 Values and Types We divide the universe of values according to types A type is a set of values and
Types and Programming Languages. Lecture 5. Extensions of simple types
Types and Programming Languages Lecture 5. Extensions of simple types Xiaojuan Cai cxj@sjtu.edu.cn BASICS Lab, Shanghai Jiao Tong University Fall, 2016 Coming soon Simply typed λ-calculus has enough structure
The design of a programming language for provably correct programs: success and failure
The design of a programming language for provably correct programs: success and failure Don Sannella Laboratory for Foundations of Computer Science School of Informatics, University of Edinburgh http://homepages.inf.ed.ac.uk/dts
Lecture #13: Type Inference and Unification. Typing In the Language ML. Type Inference. Doing Type Inference
Lecture #13: Type Inference and Unification Typing In the Language ML Examples from the language ML: fun map f [] = [] map f (a :: y) = (f a) :: (map f y) fun reduce f init [] = init reduce f init (a ::
Part III. Chapter 15: Subtyping
Part III Chapter 15: Subtyping Subsumption Subtype relation Properties of subtyping and typing Subtyping and other features Intersection and union types Subtyping Motivation With the usual typing rule
COMPUTER SCIENCE TRIPOS
CST.2001.1.1 COMPUTER SCIENCE TRIPOS Part IA Monday 4 June 2001 1.30 to 4.30 Paper 1 Answer two questions from Section A, and one question from each of Sections B, C, D and E. Submit the answers in six
A formal derivation of an executable Krivine machine
A formal derivation of an executable Krivine machine Wouter Swierstra Universiteit Utrecht IFIP WG 2.1 Meeting 68; Rome, Italy 1 β reduction (λx. t0) t1 t0 {t1/x} 2 Motivation Implementing β-reduction
Generalizing Hindley-Milner Type Inference Algorithms
Generalizing Hindley-Milner Type Inference Algorithms Bastiaan Heeren Jurriaan Hage Doaitse Swierstra institute of information and computing sciences, utrecht university technical report UU-CS-2002-031
Type Systems, Type Inference, and Polymorphism
6 Type Systems, Type Inference, and Polymorphism Programming involves a wide range of computational constructs, such as data structures, functions, objects, communication channels, and threads of control.
Last time: generic programming
1/ 45 Last time: generic programming val show : a data a string 2/ 45 This time: staging.< e >. 3/ 45 Review: abstraction Lambda abstraction λx : A.M ΛA :: K.M λa :: K.B Abstraction of type equalities
Lecture 2: SML Basics
15-150 Lecture 2: SML Basics Lecture by Dan Licata January 19, 2012 I d like to start off by talking about someone named Alfred North Whitehead. With someone named Bertrand Russell, Whitehead wrote Principia
Tradeoffs. CSE 505: Programming Languages. Lecture 15 Subtyping. Where shall we add useful completeness? Where shall we add completeness?
Tradeoffs CSE 505: Programming Languages Lecture 15 Subtyping Zach Tatlock Autumn 2017 Desirable type system properties (desiderata): soundness - exclude all programs that get stuck completeness - include
Lambda Calculus and Type Inference
Lambda Calculus and Type Inference Björn Lisper Dept. of Computer Science and Engineering Mälardalen University bjorn.lisper@mdh.se http://www.idt.mdh.se/ blr/ October 13, 2004 Lambda Calculus and Type
Chapter 13: Reference. Why reference Typing Evaluation Store Typings Safety Notes
Chapter 13: Reference Why reference Typing Evaluation Store Typings Safety Notes References Mutability So far, what we discussed does not include computational effects (also known as side effects). In
From Math to Machine A formal derivation of an executable Krivine Machine Wouter Swierstra Brouwer Seminar
From Math to Machine A formal derivation of an executable Krivine Machine Wouter Swierstra Brouwer Seminar β reduction (λx. t0) t1 t0 {t1/x} Substitution Realizing β-reduction through substitution is a
Polymorphism and Type Inference
Polymorphism and Type Inference Volker Stolz stolz@ifi.uio.no INF 3110-2008 Department of Informatics University of Oslo Initially by Gerardo Schneider. Based on John C. Mitchell s slides (Stanford U.)
Functional programming Primer I
Functional programming Primer I COS 320 Compiling Techniques Princeton University Spring 2016 Lennart Beringer 1 Characteristics of functional programming Primary notions: functions and expressions (not
Pattern Matching and Abstract Data Types
Pattern Matching and Abstract Data Types Tom Murphy VII 3 Dec 2002 0-0 Outline Problem Setup Views ( Views: A Way For Pattern Matching To Cohabit With Data Abstraction, Wadler, 1986) Active Patterns (
Modular implicits for OCaml how to assert success. Gallium Seminar,
Modular implicits for OCaml how to assert success Jacques Garrigue Nagoya University Frédéric Bour Sponsored by Jane Street LLC Gallium Seminar, 14-03-2016 Garrigue & Bour Mdular implicits and success
Types and Type Inference
Types and Type Inference Mooly Sagiv Slides by Kathleen Fisher and John Mitchell Reading: Concepts in Programming Languages, Revised Chapter 6 - handout on the course homepage Outline General discussion
l e t print_name r = p r i n t _ e n d l i n e ( Name : ^ r. name)
Chapter 8 Row polymorphism Consider the following code: type name_home = {name : s t r i n g ; home : s t r i n g } type name_mobile = {name : s t r i n g ; mobile : s t r i n g } l e t jane = {name =
Products and Records
Products and Records Michael P. Fourman February 2, 2010 1 Simple structured types Tuples Given a value v 1 of type t 1 and a value v 2 of type t 2, we can form a pair, (v 1, v 2 ), containing these values.
Where is ML type inference headed?
1 Constraint solving meets local shape inference September 2005 2 Types are good A type is a concise description of the behavior of a program fragment. Typechecking provides safety or security guarantees.
Computer Science CSC324 Wednesday February 13, Homework Assignment #3 Due: Thursday February 28, 2013, by 10 p.m.
Computer Science CSC324 Wednesday February 13, 2013 St. George Campus University of Toronto Homework Assignment #3 Due: Thursday February 28, 2013, by 10 p.m. Silent Policy A silent policy takes effect
Adding GADTs to OCaml the direct approach
Adding GADTs to OCaml the direct approach Jacques Garrigue & Jacques Le Normand Nagoya University / LexiFi (Paris) https://sites.google.com/site/ocamlgadt/ Garrigue & Le Normand Adding GADTs to OCaml 1
Exercises on ML. Programming Languages. Chanseok Oh
Exercises on ML Programming Languages Chanseok Oh chanseok@cs.nyu.edu Dejected by an arcane type error? - foldr; val it = fn : ('a * 'b -> 'b) -> 'b -> 'a list -> 'b - foldr (fn x=> fn y => fn z => (max
Mini-ML. CS 502 Lecture 2 8/28/08
Mini-ML CS 502 Lecture 2 8/28/08 ML This course focuses on compilation techniques for functional languages Programs expressed in Standard ML Mini-ML (the source language) is an expressive core subset of
Data Types The ML Type System
7 Data Types 7.2.4 The ML Type System The following is an ML version of the tail-recursive Fibonacci function introduced Fibonacci function in ML in Section 6.6.1: EXAMPLE 7.96 1. fun fib (n) = 2. let
If a program is well-typed, then a type can be inferred. For example, consider the program
CS 6110 S18 Lecture 24 Type Inference and Unification 1 Type Inference Type inference refers to the process of determining the appropriate types for expressions based on how they are used. For example,
CS 4110 Programming Languages & Logics. Lecture 28 Recursive Types
CS 4110 Programming Languages & Logics Lecture 28 Recursive Types 7 November 2014 Announcements 2 Foster office hours 11-12pm Guest lecture by Fran on Monday Recursive Types 3 Many languages support recursive
COMP 4161 NICTA Advanced Course. Advanced Topics in Software Verification. Toby Murray, June Andronick, Gerwin Klein
COMP 4161 NICTA Advanced Course Advanced Topics in Software Verification Toby Murray, June Andronick, Gerwin Klein λ 1 Last time... λ calculus syntax free variables, substitution β reduction α and η conversion
Type Checking. Error Checking
Type Checking Error Checking Dynamic checking takes place while program is running Static checking takes place during compilation Type checks Flow-of-control checks Uniqueness checks Name-related checks
Polymorphism and Type Inference
Polymorphism and Type Inference Volker Stolz stolz@ifi.uio.no Department of Informatics University of Oslo Initially by Gerardo Schneider. Based on John C. Mitchell s slides (Stanford U.) Compile-time
Handout 2 August 25, 2008
CS 502: Compiling and Programming Systems Handout 2 August 25, 2008 Project The project you will implement will be a subset of Standard ML called Mini-ML. While Mini- ML shares strong syntactic and semantic
Programming Languages and Compilers (CS 421)
Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul Agha 10/3/17
Part III Chapter 15: Subtyping
Part III Chapter 15: Subtyping Subsumption Subtype relation Properties of subtyping and typing Subtyping and other features Intersection and union types Subtyping Motivation With the usual typing rule
Subsumption. Principle of safe substitution
Recap on Subtyping Subsumption Some types are better than others, in the sense that a value of one can always safely be used where a value of the other is expected. Which can be formalized as by introducing:
Lists. Michael P. Fourman. February 2, 2010
Lists Michael P. Fourman February 2, 2010 1 Introduction The list is a fundamental datatype in most functional languages. ML is no exception; list is a built-in ML type constructor. However, to introduce
Type Inference; Parametric Polymorphism; Records and Subtyping Section and Practice Problems Mar 20-23, 2018
Harvard School of Engineering and Applied Sciences CS 152: Programming Languages Type Inference; Parametric Polymorphism; Records and Subtyping Mar 20-23, 2018 1 Type Inference (a) Recall the constraint-based
15 212: Principles of Programming. Some Notes on Continuations
15 212: Principles of Programming Some Notes on Continuations Michael Erdmann Spring 2011 These notes provide a brief introduction to continuations as a programming technique. Continuations have a rich
Greedy Algorithms 1. For large values of d, brute force search is not feasible because there are 2 d
Greedy Algorithms 1 Simple Knapsack Problem Greedy Algorithms form an important class of algorithmic techniques. We illustrate the idea by applying it to a simplified version of the Knapsack Problem. Informally,
Polymorphic lambda calculus Princ. of Progr. Languages (and Extended ) The University of Birmingham. c Uday Reddy
06-02552 Princ. of Progr. Languages (and Extended ) The University of Birmingham Spring Semester 2016-17 School of Computer Science c Uday Reddy2016-17 Handout 6: Polymorphic Type Systems 1. Polymorphic
Type Inference. Prof. Clarkson Fall Today s music: Cool, Calm, and Collected by The Rolling Stones
Type Inference Prof. Clarkson Fall 2016 Today s music: Cool, Calm, and Collected by The Rolling Stones Review Previously in 3110: Interpreters: ASTs, evaluation, parsing Formal syntax Formal semantics
(Refer Slide Time: 4:00)
Principles of Programming Languages Dr. S. Arun Kumar Department of Computer Science & Engineering Indian Institute of Technology, Delhi Lecture - 38 Meanings Let us look at abstracts namely functional
CS 6110 S14 Lecture 38 Abstract Interpretation 30 April 2014
CS 6110 S14 Lecture 38 Abstract Interpretation 30 April 2014 1 Introduction to Abstract Interpretation At this point in the course, we have looked at several aspects of programming languages: operational
Scope and Introduction to Functional Languages. Review and Finish Scoping. Announcements. Assignment 3 due Thu at 11:55pm. Website has SML resources
Scope and Introduction to Functional Languages Prof. Evan Chang Meeting 7, CSCI 3155, Fall 2009 Announcements Assignment 3 due Thu at 11:55pm Submit in pairs Website has SML resources Text: Harper, Programming
Lecture Notes on Induction and Recursion
Lecture Notes on Induction and Recursion 15-317: Constructive Logic Frank Pfenning Lecture 7 September 19, 2017 1 Introduction At this point in the course we have developed a good formal understanding
Programming Paradigms
PP 2017/18 Unit 12 Functions and Data Types in Haskell 1/45 Programming Paradigms Unit 12 Functions and Data Types in Haskell J. Gamper Free University of Bozen-Bolzano Faculty of Computer Science IDSE
Typed Lambda Calculus and Exception Handling
Typed Lambda Calculus and Exception Handling Dan Zingaro zingard@mcmaster.ca McMaster University Typed Lambda Calculus and Exception Handling p. 1/2 Untyped Lambda Calculus Goal is to introduce typing
COS 320. Compiling Techniques
Topic 5: Types COS 320 Compiling Techniques Princeton University Spring 2016 Lennart Beringer 1 Types: potential benefits (I) 2 For programmers: help to eliminate common programming mistakes, particularly
Haskell 98 in short! CPSC 449 Principles of Programming Languages
Haskell 98 in short! n Syntax and type inferencing similar to ML! n Strongly typed! n Allows for pattern matching in definitions! n Uses lazy evaluation" F definition of infinite lists possible! n Has
An update on XML types
An update on XML types Alain Frisch INRIA Rocquencourt (Cristal project) Links Meeting - Apr. 2005 Plan XML types 1 XML types 2 3 2/24 Plan XML types 1 XML types 2 3 3/24 Claim It is worth studying new
Generalised recursion and type inference for intersection types p.1
Generalised recursion and type inference for intersection types Seminar for Comete May 4th, 2004 Pascal Zimmer INRIA Sophia Antipolis Generalised recursion and type inference for intersection types p.1
CMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages Operational Semantics CMSC 330 Summer 2018 1 Formal Semantics of a Prog. Lang. Mathematical description of the meaning of programs written in that language
CS153: Compilers Lecture 14: Type Checking
CS153: Compilers Lecture 14: Type Checking Stephen Chong https://www.seas.harvard.edu/courses/cs153 Announcements Project 4 out Due Thursday Oct 25 (7 days) Project 5 out Due Tuesday Nov 13 (26 days) Project
Fundamentals of Artificial Intelligence COMP221: Functional Programming in Scheme (and LISP)
Fundamentals of Artificial Intelligence COMP221: Functional Programming in Scheme (and LISP) Prof. Dekai Wu Department of Computer Science and Engineering The Hong Kong University of Science and Technology
Beluga: A Framework for Programming and Reasoning with Deductive Systems (System Description)
Beluga: A Framework for Programming and Reasoning with Deductive Systems (System Description) Brigitte Pientka and Joshua Dunfield McGill University, Montréal, Canada {bpientka,joshua}@cs.mcgill.ca Abstract.
Types. Lecture Notes on. for Part II of the Computer Science Tripos. Prof. Andrew M. Pitts University of Cambridge Computer Laboratory
Q Lecture Notes on Types for Part II of the Computer Science Tripos Prof. Andrew M. Pitts University of Cambridge Computer Laboratory c 2015 A. M. Pitts Contents Learning Guide i 1 Introduction 1 2 ML
CS 6110 S11 Lecture 25 Typed λ-calculus 6 April 2011
CS 6110 S11 Lecture 25 Typed λ-calculus 6 April 2011 1 Introduction Type checking is a lightweight technique for proving simple properties of programs. Unlike theorem-proving techniques based on axiomatic
CLF: A logical framework for concurrent systems
CLF: A logical framework for concurrent systems Thesis Proposal Kevin Watkins Carnegie Mellon University Committee: Frank Pfenning, CMU (Chair) Stephen Brookes, CMU Robert Harper, CMU Gordon Plotkin, University
The Typed λ Calculus and Type Inferencing in ML
Notes on Types S. Arun-Kumar Department of Computer Science and Engineering Indian Institute of Technology New Delhi, 110016 email: sak@cse.iitd.ernet.in April 14, 2002 2 Chapter 1 The Typed λ Calculus
Type Processing by Constraint Reasoning
Type Processing by Constraint Reasoning Peter J. Stuckey 1,2, Martin Sulzmann 3, and Jeremy Wazny 2 1 NICTA Victoria Laboratory 2 Department of Computer Science and Software Engineering University of Melbourne,
CMSC 330: Organization of Programming Languages. OCaml Expressions and Functions
CMSC 330: Organization of Programming Languages OCaml Expressions and Functions CMSC330 Spring 2018 1 Lecture Presentation Style Our focus: semantics and idioms for OCaml Semantics is what the language
Improving Type Error Messages in OCaml
Improving Type Error Messages in OCaml Arthur Charguéraud Inria, Université Paris-Saclay, France LRI, CNRS & Univ. Paris-Sud, Université Paris-Saclay, France arthur.chargueraud@inria.fr Cryptic type error
1 Introduction. 3 Syntax
CS 6110 S18 Lecture 19 Typed λ-calculus 1 Introduction Type checking is a lightweight technique for proving simple properties of programs. Unlike theorem-proving techniques based on axiomatic semantics,
Formal Semantics. Chapter Twenty-Three Modern Programming Languages, 2nd ed. 1
Formal Semantics Chapter Twenty-Three Modern Programming Languages, 2nd ed. 1 Formal Semantics At the beginning of the book we saw formal definitions of syntax with BNF And how to make a BNF that generates
Types-2. Polymorphism
Types-2 Polymorphism Type reconstruction (type inference) for a simple PL Typing functions Coercion, conversion, reconstruction Rich area of programming language research as people try to provide safety
Three Applications of Strictness in the Efficient Implementaton of Higher-Order Terms
Three Applications of Strictness in the Efficient Implementaton of Higher-Order Terms Frank Pfenning Workshop on Implementation of Logic Réunion Island, France November 11, 2000 Joint work with Carsten
Type Systems COMP 311 Rice University Houston, Texas
Rice University Houston, Texas 1 Type Systems for Programming Language were invented by mathematicians before electronic computers were invented. What is a type? A meaningful subset of the set of the domain
CS-XXX: Graduate Programming Languages. Lecture 9 Simply Typed Lambda Calculus. Dan Grossman 2012
CS-XXX: Graduate Programming Languages Lecture 9 Simply Typed Lambda Calculus Dan Grossman 2012 Types Major new topic worthy of several lectures: Type systems Continue to use (CBV) Lambda Caluclus as our