Type Declarations. Γ <num> : num [... <id> τ... ] <id> : τ Γ true : bool Γ false : bool Γ e 1 : num Γ e 2 : num Γ. {+ e 1 e 2 } : num
|
|
|
- August Andrews
- 5 years ago
- Views:
Transcription
1 Type Declarations Γ <num> : num [... <id> τ... ] <id> : τ Γ true : bool Γ false : bool Γ e 1 : num Γ e 2 : num Γ {+ e 1 e 2 } : num Γ e 1 : bool Γ e 2 : τ 0 Γ e 3 : τ 0 Γ {if e 1 e 2 e 3 } : τ 0 Γ[ <id> τ 1 ] e : τ 0 Γ {fun {<id> : τ 1 } e} : (τ 1 τ 0 ) Γ e 0 : (τ 1 τ 0 ) Γ e 1 : τ 1 Γ {e 0 e 1 } : τ 0 1
2 Type Inference Γ <num> : num [... <id> τ... ] <id> : τ Γ true : bool Γ false : bool Γ e 1 : num Γ e 2 : num Γ {+ e 1 e 2 } : num Γ e 1 : bool Γ e 2 : τ 0 Γ e 3 : τ 0 Γ {if e 1 e 2 e 3 } : τ 0 Γ[ <id> τ 1 ] e : τ 0 Γ {fun {<id>} e} : (τ 1 τ 0 ) Γ e 0 : (τ 1 τ 0 ) Γ e 1 : τ 1 Γ {e 0 e 1 } : τ 0 2
3 Do the rules still work? (Yes.) [x num] x : num [x num] 1 : num [x num] {+ x 1} : num {fun {x} {+ x 1}} : (num -> num) But how do we implement them now? 3
4 Type Inference Type inference is the process of inserting type annotations where the programmer omits them We ll use explicit question marks, to make it clear where types are omitted {fun {x :?} {+ x 1}} 4
5 Type Inference Type inference is the process of inserting type annotations where the programmer omits them We ll use explicit question marks, to make it clear where types are omitted {fun {x :?} {+ x 1}} <typeexpr> ::= num bool (<typeexpr> -> <typeexpr>)? 5
6 Type Inference {fun {x :?} {+ x 1} } 6
7 Type Inference {fun {x :?} {+ x 1} } T 1 7
8 Type Inference {fun {x :?} {+ x 1} } T 1 num 8
9 Type Inference {fun {x :?} {+ x 1} } T 1 num num T 1 = num 9
10 Type Inference {fun {x :?} {+ x 1} } T 1 num (num num) num T 1 = num 10
11 Type Inference {fun {x :?} {+ x 1} } T 1 num (num num) num T 1 = num Create a new type variable for each? Change type comparison to install type equivalences 11
12 Type Inference {fun {x :?} {+ x 1} } T 1 num (num num) num T 1 = num {fun {x :?} {if true 1 x} } 12
13 Type Inference {fun {x :?} {+ x 1} } T 1 num (num num) num T 1 = num {fun {x :?} {if true 1 x} } bool 13
14 Type Inference {fun {x :?} {+ x 1} } T 1 num (num num) num T 1 = num {fun {x :?} {if true 1 x} } bool int 14
15 Type Inference {fun {x :?} {+ x 1} } T 1 num (num num) num T 1 = num {fun {x :?} {if true 1 x} } bool int T 1 15
16 Type Inference {fun {x :?} {+ x 1} } T 1 num (num num) num T 1 = num {fun {x :?} {if true 1 x} } bool int T 1 num T 1 = num 16
17 Type Inference {fun {x :?} {+ x 1} } T 1 num (num num) num T 1 = num {fun {x :?} {if true 1 x} } bool int T 1 num (num num) T 1 = num 17
18 Type Inference: Impossible Cases {fun {x :?} {if x 1 x} } 18
19 Type Inference: Impossible Cases {fun {x :?} {if x 1 x} } T 1 19
20 Type Inference: Impossible Cases {fun {x :?} {if x 1 x} } T 1 num 20
21 Type Inference: Impossible Cases {fun {x :?} {if x 1 x} } T 1 num T 1 21
22 Type Inference: Impossible Cases {fun {x :?} {if x 1 x} } T 1 num T 1 no type: T 1 can't be both bool and num 22
23 Type Inference: Many Cases {fun {y :?} y} 23
24 Type Inference: Many Cases {fun {y :?} y} T 1 24
25 Type Inference: Many Cases {fun {y :?} y} T 1 (T 1 T 1 ) 25
26 Type Inference: Many Cases {fun {y :?} y} T 1 (T 1 T 1 ) Sometimes, more than one type works (num num) (bool bool) ((num bool) (num bool)) so the type checker leaves variables in the reported type 26
27 Type Inference: Function Calls {{fun {y :?} y} {fun {x :?} {+ x 1}}} 27
28 Type Inference: Function Calls {{fun {y :?} y} {fun {x :?} {+ x 1}}} (T 1 T 1 ) 28
29 Type Inference: Function Calls {{fun {y :?} y} {fun {x :?} {+ x 1}}} (T 1 T 1 ) (num num) 29
30 Type Inference: Function Calls {{fun {y :?} y} {fun {x :?} {+ x 1}}} (T 1 T 1 ) (num num) T 1 = (num num) 30
31 Type Inference: Function Calls {{fun {y :?} y} {fun {x :?} {+ x 1}}} (T 1 T 1 ) (num num) (num num) T 1 = (num num) 31
32 Type Inference: Function Calls {fun {y :?} {y 7} } 32
33 Type Inference: Function Calls {fun {y :?} {y 7} } T 1 33
34 Type Inference: Function Calls {fun {y :?} {y 7} } T 1 num 34
35 Type Inference: Function Calls {fun {y :?} {y 7} } T 1 num T 2 T 1 = (num T 2 ) 35
36 Type Inference: Function Calls {fun {y :?} {y 7} } T 1 num T 2 T 1 = (num T 2 ) ((num T 2 ) T 2 ) 36
37 Type Inference: Function Calls {fun {y :?} {y 7} } T 1 num T 2 T 1 = (num T 2 ) ((num T 2 ) T 2 ) In general, create a new type variable record for the result of a function call 37
38 Type Inference: Cyclic Equations {fun {x :?} {x x} } 38
39 Type Inference: Cyclic Equations {fun {x :?} {x x} } T 1 39
40 Type Inference: Cyclic Equations {fun {x :?} {x x} } T 1 T 1 40
41 Type Inference: Cyclic Equations T 1 can t be int T 1 can t be bool Suppose T 1 is (T 2 T 3 ) T 2 must be T 1 {fun {x :?} {x x} } T 1 T 1 no type: T 1 can't be (T 1...) So we won t get anywhere! 41
42 Type Inference: Cyclic Equations {fun {x :?} {x x} } T 1 T 1 no type: T 1 can't be (T 1...) The occurs check: When installing a type equivalence, make sure that the new type for T doesn t already contain T 42
43 Type Unification Unify a type variable T with a type τ 2 : If T is set to τ 1, unify τ 1 and τ 2 If τ 2 is already equivalent to T, succeed If τ 2 contains T, then fail Otherwise, set T to τ 2 and succeed Unify a type τ 1 to type τ 2 : If τ 2 is a type variable T, then unify T and τ 1 If τ 1 and τ 2 are both num or bool, succeed If τ 1 is (τ 3 τ 4 ) and τ 2 is (τ 5 τ 6 ), then unify τ 3 with τ 5 unify τ 4 with τ 6 Otherwise, fail 43
44 TIFAE Grammar <TIFAE> ::= <num> {+ <TIFAE> <TIFAE>} {- <TIFAE> <TIFAE>} <id> {fun {<id> : <TE>} <TIFAE>} {<TIFAE> <TIFAE>} {if0 <TIFAE> <TIFAE> <TIFAE>} {rec {<id> : <TE> <TIFAE>} <TIFAE>} <TE> ::= num (<TE> -> <TE>)? NEW 44
45 Representing Expressions (define-type TFAE [num (n : number)] [add (l : TFAE) (r : TFAE)] [sub (l : TFAE) (r : TFAE)] [id (name : symbol)] [fun (name : symbol) (t : TE) ; different (body : TFAE)] [app (rator : TFAE) (rand : TFAE)]) 45
46 Representing Type Variables (define-type Type [numt] [boolt] [arrowt (arg : Type) (result : Type)] [vart (is : (boxof MaybeType))]) (define-type TE [numte] [boolte] [arrowte (arg : TE) (result : TE)] [guesste]) (define-type MaybeType [none] [some (t : Type)]) 46
47 Parsing Types (define parse-type : (TE -> Type) (lambda (te) (type-case TE te [numte () (numt)] [boolte () (boolt)] [arrowte (d r) (arrowt (parse-type d) (parse-type r))] [guesste () (vart (box (none)))]))) 47
48 Type Unification (define unify! : (Type Type -> ()) (lambda (t1 t2) (type-case Type t1 [vart (b) (type-case MaybeType (unbox b) [some (t1-2) (unify! t1-2 t2)] [none () (type-case Type t2 [vart (b2) (type-case MaybeType (unbox b2) [some (t2-2) (unify! t1 t2-2)] [none () (if (eq? b b2) (values) (begin (set-box! b (some t2)) (values)))])] [else...])])] [numt ()...] [boolt ()...] [arrowt (d1 r1)...]))) 48
49 Type Unification (define unify! : (Type Type -> ()) (lambda (t1 t2) (type-case Type t1 [vart (b) (type-case MaybeType (unbox b) [some (t1-2) (unify! t1-2 t2)] [none () (type-case Type t2 [vart (b2)...] [else (if (occurs? b t2) (error 'type-check "failed") (begin (set-box! b (some t2)) (values)))])])] [numt ()...] [boolt ()...] [arrowt (d1 r1)...]))) 49
50 Type Unification (define unify! : (Type Type -> ()) (lambda (t1 t2) (type-case Type t1 [vart (b)...] [numt () (type-case Type t2 [vart (b) (unify! t2 t1)] [numt () (values)] [else (error 'type-check "failed")])] [boolt () (type-case Type t2 [vart (b) (unify! t2 t1)] [boolt () (values)] [else (error 'type-check "failed")])] [arrowt (d1 r1) (type-case Type t2 [vart (b) (unify! t2 t1)] [arrowt (d2 r2) (begin (unify! d1 d2) (unify! r1 r2))] [else (error 'type-check "failed")])]))) 50
51 Occurs Check (define occurs? : ((boxof MaybeType) Type -> boolean) (lambda (b t) (type-case Type t [vart (b2) (or (eq? b b2) (type-case MaybeType (unbox b2) [none () false] [some (t2-2) (occurs? b t2-2)]))] [numt () false] [arrowt (d r) (or (occurs? b d) (occurs? b r))]))) 51
52 TIFAE Type Checker (define typecheck : (FAE TypeEnv -> Type) (lambda (fae env) (type-case FAE fae... [num (n) (numt)]...))) 52
53 TIFAE Type Checker (define typecheck : (FAE TypeEnv -> Type) (lambda (fae env) (type-case FAE fae... [add (l r)... (typecheck l env) (typecheck r env)...]...))) 53
54 TIFAE Type Checker (define typecheck : (FAE TypeEnv -> Type) (lambda (fae env) (type-case FAE fae... [add (l r) (begin (unify! (typecheck l env) (numt) l) (unify! (typecheck r env) (numt) r) (numt))]...))) 54
55 TIFAE Type Checker (define typecheck : (FAE TypeEnv -> Type) (lambda (fae env) (type-case FAE fae... [id (name) (get-type name env)] [fun (name te body) (local [(define arg-type (parse-type te))] (arrowt arg-type (typecheck body (abind name arg-type env))))]...))) 55
56 TIFAE Type Checker (define typecheck : (FAE TypeEnv -> Type) (lambda (fae env) (type-case FAE fae... [app (fn arg)... (typecheck fn env) (typecheck arg env)...]...))) 56
57 TIFAE Type Checker (define typecheck : (FAE TypeEnv -> Type) (lambda (fae env) (type-case FAE fae... [app (fn arg) (local [(define result-type (vart (box (none))))]... (arrowt (typecheck arg env) result-type)... (typecheck fn env)...)]...))) 57
58 TIFAE Type Checker (define typecheck : (FAE TypeEnv -> Type) (lambda (fae env) (type-case FAE fae... [app (fn arg) (local [(define result-type (vart (box (none))))] (begin (unify! (arrowt (typecheck arg env) result-type) (typecheck fn env) fn) result-type))]...))) 58
59 TIFAE Type Checker (define typecheck : (FAE TypeEnv -> Type) (lambda (fae env) (type-case FAE fae... [if0 (test-expr then-expr else-expr)... (typecheck test-expr env) (typecheck then-expr env) (typecheck else-expr env)...]...))) 59
60 TIFAE Type Checker (define typecheck : (FAE TypeEnv -> Type) (lambda (fae env) (type-case FAE fae... [if0 (test-expr then-expr else-expr) (begin (unify! (typecheck test-expr env) (numt) test-expr)... (typecheck then-expr env) (typecheck else-expr env)...)]...))) 60
61 TIFAE Type Checker (define typecheck : (FAE TypeEnv -> Type) (lambda (fae env) (type-case FAE fae... [if0 (test-expr then-expr else-expr) (begin (unify! (typecheck test-expr env) (numt) test-expr) (local [(define test-ty (typecheck then-expr env))] (begin (unify! test-ty (typecheck else-expr env) else-expr) test-ty)))]...))) 61
62 TIFAE Type Checker (define typecheck : (FAE TypeEnv -> Type) (lambda (fae env) (type-case FAE fae... [rec (name ty rhs-expr body-expr) (local [(define rhs-ty (parse-type ty)) (define new-ds (abind name rhs-ty env))] (begin (unify! rhs-ty (typecheck rhs-expr new-ds) rhs-expr) (typecheck body-expr new-ds)))]...))) 62
Type Soundness. Type soundness is a theorem of the form If e : τ, then running e never produces an error
Type Soundness Type soundness is a theorem of the form If e : τ, then running e never produces an error 1 Type Soundness Type soundness is a theorem of the form If e : τ, then running e never produces
Type Declarations. [... <id> τ... ] <id> : τ. Γ <num> : number. Γ true : boolean. Γ false : boolean. Γ e 1 : number.
![Type Declarations. [... <id> τ... ] <id> : τ. Γ <num> : number. Γ true : boolean. Γ false : boolean. Γ e 1 : number.](/thumbs/95/123652061.jpg "Type Declarations. [... <id> τ... ] <id> : τ. Γ <num> : number. Γ true : boolean. Γ false : boolean. Γ e 1 : number.")
Type Inference 1 Type Declarations Γ : number Γ true : boolean Γ e 1 : number [... τ... ] : τ Γ false : boolean Γ e 2 : number Γ {+ e 1 e 2 } : number Γ e 1 : boolean Γ e 2 : τ 0 Γ e 3
Typed Recursion {with {mk-rec : (((num -> num) -> (num -> num)) -> (num -> num)) {fun {body : ((num -> num) -> (num -> num))} {{fun {fx :
Recursion {with {mk-rec {fun {body} {{fun {fx} {fx fx}} {fun {fx} {{fun {f} {body f}} {fun {x} {{fx fx} x}}}}}}} {with {fib {mk-rec {fun {fib} {fun {n} {if0 n 1 {if0 {- n 1} 1 {+ {fib {- n 1}} {fib {-
Types and evaluation
Type Soundness 1 Types and evaluation Why is a type system useful? It can rule out ill-formed programs before we run them What information can a type system give us? The type of data the program should
Mid-Term 2 Grades
Mid-Term 2 Grades 100 46 1 HW 9 Homework 9, in untyped class interpreter: Add instanceof Restrict field access to local class Implement overloading (based on argument count) Due date is the same as for
Higher-Order Functions
Higher-Order Functions 1 Why Functions as Values Abstraction is easier with functions as values abstract over add and sub cases filter, map, etc. What are objects? Callbacks? Separate deffun form becomes
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
"Good" vs. "Bad" Expressions. ; interp-expr FAE... -> FAE-Value
"Good" vs. "Bad" Expressions ; interp-expr FAE... -> FAE-Value 1 "Good" vs. "Bad" Expressions ; interp-expr FAE... -> FAE-Value Does interp-expr produce a value for all expressions? 2 "Good" vs. "Bad"
Higher-Order Functions (Part I)
Higher-Order Functions (Part I) 1 Why Functions as Values Abstraction is easier with functions as values abstract over add and sub cases filter, map, etc. What are objects? Callbacks? Separate deffun form
cs173: Programming Languages Final Exam
cs173: Programming Languages Final Exam Fall 2002 Please read this page of instructions before you turn the page! This exam is worth 102 points. We will assign partial credit to partial responses, provided
Quiz. Question #1: What is the value of the following expression? {+ 1 2} Wrong answer: 0 Wrong answer: 42. Answer: 3 1-4
Quiz Question #1: What is the value of the following expression? Wrong answer: 0 Wrong answer: 42 Answer: 3 {+ 1 2} 1-4 Quiz Question #2: What is the value of the following expression? Wrong answer: error
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
Principles of Programming Languages
Principles of Programming Languages Slides by Dana Fisman based on book by Mira Balaban and lecuture notes by Michael Elhadad Lesson 15 Type Inference Collaboration and Management Dana Fisman www.cs.bgu.ac.il/~ppl172
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
1. For every evaluation of a variable var, the variable is bound.
7 Types We ve seen how we can use interpreters to model the run-time behavior of programs. Now we d like to use the same technology to analyze or predict the behavior of programs without running them.
Lecture 15 CIS 341: COMPILERS
Lecture 15 CIS 341: COMPILERS Announcements HW4: OAT v. 1.0 Parsing & basic code generation Due: March 28 th No lecture on Thursday, March 22 Dr. Z will be away Zdancewic CIS 341: Compilers 2 Adding Integers
Comp 311: Sample Midterm Examination
Comp 311: Sample Midterm Examination October 29, 2007 Name: Id #: Instructions 1. The examination is closed book. If you forget the name for a Scheme operation, make up a name for it and write a brief
State. Substitution relies on an identifer having a fxed value
Part 1 1 State Substitution relies on an identifer having a fxed value {let {[x 5]} {let {[f {lambda {y} {+ x y}}]}... {f 1}}} = {let {[f {lambda {y} {+ 5 y}}]}... {f 1}} because x cannot change In Plait,
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
ML 4 Unification Algorithm
ML 4 Unification Algorithm CS 421 Fall 2017 Revision 1.0 Assigned Thursday, October 19, 201y Due October 25-27, 2017 Extension None past the allowed lab sign-up time 1 Change Log 1.0 Initial Release. 2
Typing Control. Chapter Conditionals
Chapter 26 Typing Control 26.1 Conditionals Let s expand our language with a conditional construct. We can use if0 like before, but for generality it s going to be more convenient to have a proper conditional
CS131 Typed Lambda Calculus Worksheet Due Thursday, April 19th
CS131 Typed Lambda Calculus Worksheet Due Thursday, April 19th Name: CAS ID (e.g., abc01234@pomona.edu): I encourage you to collaborate. collaborations below. Please record your Each question is worth
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
Non-Functional Procedures
Functional Programs So far, the language that we ve implemented is purely functional A function produces the same result every time for the same arguments Real programming languages do not behave this
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
Programming Languages Assignment #7
Programming Languages Assignment #7 December 2, 2007 1 Introduction This assignment has 20 points total. In this assignment, you will write a type-checker for the PolyMinML language (a language that is
CSE-321: Assignment 8 (100 points)
CSE-321: Assignment 8 (100 points) gla@postech.ac.kr Welcome to the final assignment of CSE-321! In this assignment, you will implement a type reconstruction algorithm (the algorithm W discussed in class)
Midterm 1. CMSC 430 Introduction to Compilers Spring Instructions Total 100. Name: March 14, 2012
Name: Midterm 1 CMSC 430 Introduction to Compilers Spring 2012 March 14, 2012 Instructions This exam contains 8 pages, including this one. Make sure you have all the pages. Write your name on the top of
Chapter 6 Intermediate Code Generation
Chapter 6 Intermediate Code Generation Outline Variants of Syntax Trees Three-address code Types and declarations Translation of expressions Type checking Control flow Backpatching Introduction Intermediate
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
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
Lecture 12: Conditional Expressions and Local Binding
Lecture 12: Conditional Expressions and Local Binding Introduction Corresponds to EOPL 3.3-3.4 Please review Version-1 interpreter to make sure that you understand how it works Now we will extend the basic
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,
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
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
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 ::
COMP520 - GoLite Type Checking Specification
COMP520 - GoLite Type Checking Specification Vincent Foley March 5, 2017 1 Introduction This document presents the typing rules for all the language constructs (i.e. declarations, statements, expressions)
Semantics of programming languages
Semantics of programming languages Informatics 2A: Lecture 27 John Longley School of Informatics University of Edinburgh jrl@inf.ed.ac.uk 21 November, 2011 1 / 19 1 2 3 4 2 / 19 Semantics for programming
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
CMSC 330: Organization of Programming Languages. Rust Basics
CMSC 330: Organization of Programming Languages Rust Basics CMSC330 Spring 2018 1 Organization It turns out that a lot of Rust has direct analogues in OCaml So we will introduce its elements with comparisons
Tail Calls. CMSC 330: Organization of Programming Languages. Tail Recursion. Tail Recursion (cont d) Names and Binding. Tail Recursion (cont d)
CMSC 330: Organization of Programming Languages Tail Calls A tail call is a function call that is the last thing a function does before it returns let add x y = x + y let f z = add z z (* tail call *)
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:
Two Problems. Programming Languages and Compilers (CS 421) Type Inference - Example. Type Inference - Outline. Type Inference - Example
Two Problems Programming Languages and Compilers (CS 421) Sasa Misailovic 4110 SC, UIUC https://courses.engr.illinois.edu/cs421/fa2017/cs421a Based in part on slides by Mattox Beckman, as updated by Vikram
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";
Introduction to Typed Racket. The plan: Racket Crash Course Typed Racket and PL Racket Differences with the text Some PL Racket Examples
Introduction to Typed Racket The plan: Racket Crash Course Typed Racket and PL Racket Differences with the text Some PL Racket Examples Getting started Find a machine with DrRacket installed (e.g. the
Static Checking and Type Systems
1 Static Checking and Type Systems Chapter 6 COP5621 Compiler Construction Copyright Robert van Engelen, Florida State University, 2007-2009 2 The Structure of our Compiler Revisited Character stream Lexical
Semantics of programming languages
Semantics of programming languages Informatics 2A: Lecture 28 Mary Cryan School of Informatics University of Edinburgh mcryan@inf.ed.ac.uk 21 November 2018 1 / 18 Two parallel pipelines A large proportion
At build time, not application time. Types serve as statically checkable invariants.
Static Typing Thus far we have only considered statically typed languages. CMPSCI 630: Programming Languages Static and Dynamic Typing Spring 2008 (with thanks to Robert Harper) Type system is based on
CMSC 330: Organization of Programming Languages. Operational Semantics
CMSC 330: Organization of Programming Languages Operational Semantics Notes about Project 4, Parts 1 & 2 Still due today (7/2) Will not be graded until 7/11 (along with Part 3) You are strongly encouraged
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
CS 342 Lecture 8 Data Abstraction By: Hridesh Rajan
CS 342 Lecture 8 Data Abstraction By: Hridesh Rajan 1 Com S 342 so far So far we have studied: Language design goals, Basic functional programming, Flat recursion over lists, Notion of Scheme procedures
Threads. {seqn {spawn EXPR 1 } {spawn EXPR 2 }} Runs EXPR 1 and EXPR 2 in any order, even interleaved with each other
Sequential Programs So far, the language that we ve implemented is deterministic. Running a program multiple times (or computing things slightly more quickly or slowly) does not change the result of the
CIS 341 Final Examination 4 May 2017
CIS 341 Final Examination 4 May 2017 1 /14 2 /15 3 /12 4 /14 5 /34 6 /21 7 /10 Total /120 Do not begin the exam until you are told to do so. You have 120 minutes to complete the exam. There are 14 pages
COMP520 - GoLite Type Checking Specification
COMP520 - GoLite Type Checking Specification Vincent Foley April 8, 2018 1 Introduction This document presents the typing rules for all the language constructs (i.e. declarations, statements, expressions)
CS153: Compilers Lecture 16: Local Optimization II
CS153: Compilers Lecture 16: Local Optimization II Stephen Chong https://www.seas.harvard.edu/courses/cs153 Announcements Project 4 out Due today! Project 5 out Due Tuesday Nov 13 (19 days) Project 6 out
Project 6 Due 11:59:59pm Thu, Dec 10, 2015
Project 6 Due 11:59:59pm Thu, Dec 10, 2015 Updates None yet. Introduction In this project, you will add a static type checking system to the Rube programming language. Recall the formal syntax for Rube
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
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
Metaprogramming assignment 3
Metaprogramming assignment 3 Optimising embedded languages Due at noon on Thursday 29th November 2018 This exercise uses the BER MetaOCaml compiler, which you can install via opam. The end of this document
Types and Static Type Checking (Introducing Micro-Haskell)
Types and Static (Introducing Micro-Haskell) Informatics 2A: Lecture 13 Alex Simpson School of Informatics University of Edinburgh als@inf.ed.ac.uk 16 October, 2012 1 / 21 1 Types 2 3 4 2 / 21 Thus far
Implementing Recursion
Implementing Recursion Shriram Krishnamurthi 2003-09-19 We ve seen that there are (at least two, fairly distinct ways of representing environments To implement recursive environments, we need to provide
Programs as data Parsing cont d; first-order functional language, type checking
Programs as data Parsing cont d; first-order functional language, type checking Peter Sestoft Monday 2009-09-14 Plan for today Exercises week 2 Parsing: LR versus LL How does an LR parser work Hand-writing
Semantics of programming languages
Semantics of programming languages Informatics 2A: Lecture 27 Alex Simpson School of Informatics University of Edinburgh als@inf.ed.ac.uk 18 November, 2014 1 / 18 Two parallel pipelines A large proportion
Motivation At the very begining Ni won t be complete until it has static typing 1 Maintenance needs nipkgs: 1M sloc Errors hard to spot 1 Eelco Dolstr
A type-system for Ni Théophane Hufschmitt October 28 2017 1 / 24 Motivation At the very begining Ni won t be complete until it has static typing 1 Maintenance needs nipkgs: 1M sloc Errors hard to spot
Lecture 3: Expressions
CS 7400 September 23 30, 2009 Dr. Wand Readings: EOPL3, Secs. 3.1 3.5 Lecture 3: Expressions Key Concepts: syntax and semantics expressed and denoted values expressions environment specifying the behavior
CS4215 Programming Language Implementation. Martin Henz
CS4215 Programming Language Implementation Martin Henz Thursday 26 January, 2012 2 Chapter 4 The Language simpl In this chapter, we are exting the language epl in order to provide a more powerful programming
Ornaments in ML. Thomas Williams, Didier Rémy. April 18, Inria - Gallium
Ornaments in ML Thomas Williams, Didier Rémy Inria - Gallium April 18, 2017 1 Motivation Two very similar functions let rec add m n = match m with Z n S m S (add m n) let rec append ml nl = match ml with
Overloading, Type Classes, and Algebraic Datatypes
Overloading, Type Classes, and Algebraic Datatypes Delivered by Michael Pellauer Arvind Computer Science and Artificial Intelligence Laboratory M.I.T. September 28, 2006 September 28, 2006 http://www.csg.csail.mit.edu/6.827
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
Typing Data. Chapter Recursive Types Declaring Recursive Types
Chapter 27 Typing Data 27.1 Recursive Types 27.1.1 Declaring Recursive Types We saw in the previous lecture how rec was necessary to write recursive programs. But what about defining recursive types? Recursive
Typed Racket: Racket with Static Types
Typed Racket: Racket with Static Types Version 5.0.2 Sam Tobin-Hochstadt November 6, 2010 Typed Racket is a family of languages, each of which enforce that programs written in the language obey a type
Boolean expressions. Elements of Programming Languages. Conditionals. What use is this?
Boolean expressions Elements of Programming Languages Lecture 3: Booleans, conditionals, and types James Cheney So far we ve considered only a trivial arithmetic language L Arith Let s extend L Arith with
Recap: Functions as first-class values
Recap: Functions as first-class values Arguments, return values, bindings What are the benefits? Parameterized, similar functions (e.g. Testers) Creating, (Returning) Functions Iterator, Accumul, Reuse
An Introduction to Functions
Chapter 4 An Introduction to Functions Through the agency of with, we have added identifiers and the ability to name expressions to the language. Much of the time, though, simply being able to name an
Procedures. EOPL3: Section 3.3 PROC and App B: SLLGEN
Procedures EOPL3: Section 3.3 PROC and App B: SLLGEN The PROC language Expression ::= proc (Identifier) Expression AST: proc-exp (var body) Expression ::= (Expression Expression) AST: call-exp (rator rand)
Introduction to ML. Mooly Sagiv. Cornell CS 3110 Data Structures and Functional Programming
Introduction to ML Mooly Sagiv Cornell CS 3110 Data Structures and Functional Programming Typed Lambda Calculus Chapter 9 Benjamin Pierce Types and Programming Languages Call-by-value Operational Semantics
ENGI 1020 Introduction to Computer Programming J U L Y 5, R E Z A S H A H I D I
ENGI 1020 Introduction to Computer Programming J U L Y 5, 2 0 1 0 R E Z A S H A H I D I Passing by value Recall that it is possible to call functions with variable names different than the parameters in
Programming Languages
CSE 130 : Spring 2011 Programming Languages Lecture 3: Crash Course Ctd, Expressions and Types Ranjit Jhala UC San Diego A shorthand for function binding # let neg = fun f -> fun x -> not (f x); # let
Programming Languages Lecture 14: Sum, Product, Recursive Types
CSE 230: Winter 200 Principles of Programming Languages Lecture 4: Sum, Product, Recursive Types The end is nigh HW 3 No HW 4 (= Final) Project (Meeting + Talk) Ranjit Jhala UC San Diego Recap Goal: Relate
CPSC 411, 2015W Term 2 Midterm Exam Date: February 25, 2016; Instructor: Ron Garcia
CPSC 411, 2015W Term 2 Midterm Exam Date: February 25, 2016; Instructor: Ron Garcia This is a closed book exam; no notes; no calculators. Answer in the space provided. There are 8 questions on 14 pages,
Begin at the beginning
Begin at the beginning Expressions (Syntax) Exec-time Dynamic Values (Semantics) Compile-time Static Types 1. Programmer enters expression 2. ML checks if expression is well-typed Using a precise set of
Flang typechecker Due: February 27, 2015
CMSC 22610 Winter 2015 Implementation of Computer Languages I Flang typechecker Due: February 27, 2015 Project 3 February 9, 2015 1 Introduction The third project is to implement a type checker for Flang,
COP5621 Exam 3 - Spring 2005
COP5621 Exam 3 - Spring 2005 Name: (Please print) Put the answers on these sheets. Use additional sheets when necessary. Show how you derived your answer when applicable (this is required for full cred
CMSC 330: Organization of Programming Languages. Formal Semantics of a Prog. Lang. Specifying Syntax, Semantics
Recall Architecture of Compilers, Interpreters CMSC 330: Organization of Programming Languages Source Scanner Parser Static Analyzer Operational Semantics Intermediate Representation Front End Back End
Introduction to ML. Mooly Sagiv. Cornell CS 3110 Data Structures and Functional Programming
Introduction to ML Mooly Sagiv Cornell CS 3110 Data Structures and Functional Programming The ML Programming Language General purpose programming language designed by Robin Milner in 1970 Meta Language
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
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
CS 320: Concepts of Programming Languages
CS 320: Concepts of Programming Languages Wayne Snyder Computer Science Department Boston University Lecture 04: Basic Haskell Continued o Polymorphic Types o Type Inference with Polymorphism o Standard
Types, Type Inference and Unification
Types, Type Inference and Unification Mooly Sagiv Slides by Kathleen Fisher and John Mitchell Cornell CS 6110 Summary (Functional Programming) Lambda Calculus Basic ML Advanced ML: Modules, References,
How does ML deal with +?
How does ML deal with +? Moscow ML version 2.00 (June 2000) - op +; > val it = fn : int * int -> int - 1 + 1; > val it = 2 : int - 1.0 + 1.0; > val it = 2.0 : real - false + false;! Overloaded + cannot
MIT Top-Down Parsing. Martin Rinard Laboratory for Computer Science Massachusetts Institute of Technology
MIT 6.035 Top-Down Parsing Martin Rinard Laboratory for Computer Science Massachusetts Institute of Technology Orientation Language specification Lexical structure regular expressions Syntactic structure
n n Try tutorial on front page to get started! n spring13/ n Stack Overflow!
Announcements n Rainbow grades: HW1-6, Quiz1-5, Exam1 n Still grading: HW7, Quiz6, Exam2 Intro to Haskell n HW8 due today n HW9, Haskell, out tonight, due Nov. 16 th n Individual assignment n Start early!
Compilers and computer architecture: Semantic analysis
1 / 1 Compilers and computer architecture: Semantic analysis Martin Berger Alex Jeffery October 2018 Recall the function of compilers 2 / 1 3 / 1 Recall the structure of compilers Source program Lexical
Types and Static Type Checking (Introducing Micro-Haskell)
Types and Static (Introducing Micro-Haskell) Informatics 2A: Lecture 14 John Longley School of Informatics University of Edinburgh jrl@inf.ed.ac.uk 17 October 2017 1 / 21 1 Types 2 3 4 2 / 21 So far in
Semantic Processing (Part 2)
Semantic Processing (Part 2) All Projects Due: Fray 12-2-05, Noon Final: Monday, December 5, 2005, 10:15-12:05 Comprehensive 1 Recursive Type Definitions type MyRec is record f1: integer; f2: array of
CSCE 314 Programming Languages. Type System
CSCE 314 Programming Languages Type System Dr. Hyunyoung Lee 1 Names Names refer to different kinds of entities in programs, such as variables, functions, classes, templates, modules,.... Names can be
Axiomatic Rules. Lecture 18: Axiomatic Semantics & Type Safety. Correctness using Axioms & Rules. Axiomatic Rules. Steps in Proof
Lecture 18: Axiomatic Semantics & Type Safety CSCI 131 Fall, 2011 Kim Bruce Axiomatic Rules Assignment axiom: - {P [expression / id]} id := expression {P} - Ex: {a+47 > 0} x := a+47 {x > 0} - {x > 1} x
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
CS1622. Today. A Recursive Descent Parser. Preliminaries. Lecture 9 Parsing (4)
CS1622 Lecture 9 Parsing (4) CS 1622 Lecture 9 1 Today Example of a recursive descent parser Predictive & LL(1) parsers Building parse tables CS 1622 Lecture 9 2 A Recursive Descent Parser. Preliminaries
CS152: Programming Languages. Lecture 11 STLC Extensions and Related Topics. Dan Grossman Spring 2011
CS152: Programming Languages Lecture 11 STLC Extensions and Related Topics Dan Grossman Spring 2011 Review e ::= λx. e x e e c v ::= λx. e c τ ::= int τ τ Γ ::= Γ, x : τ (λx. e) v e[v/x] e 1 e 1 e 1 e