Type Soundness. Type soundness is a theorem of the form If e : τ, then running e never produces an error
|
|
|
- Alannah Loren Martin
- 5 years ago
- Views:
Transcription
1 Type Soundness Type soundness is a theorem of the form If e : τ, then running e never produces an error 1
2 Type Soundness Type soundness is a theorem of the form If e : τ, then running e never produces an error If we add division and arrays, then some errors are ok: If e : τ, then running e never produces an error except divide-by-zero or array-out-of-bounds In general, soundness rules out a certain class of run-time errors 2
3 Type Soundness Type soundness is a theorem of the form If e : τ, then running e never produces an error If we add division and arrays, then some errors are ok: If e : τ, then running e never produces an error except divide-by-zero or array-out-of-bounds In general, soundness rules out a certain class of run-time errors Soundness fails bug in type rules or bug in eval 3
4 Quiz What is the type of the following expression? {fun {x} {+ x 1}} 4
5 Quiz What is the type of the following expression? {fun {x} {+ x 1}} Answer: Yet another trick question; it s not an expression in our typed language, because the argument type is missing 5
6 Quiz What is the type of the following expression? {fun {x} {+ x 1}} Answer: Yet another trick question; it s not an expression in our typed language, because the argument type is missing But it seems like the answer should be (num num) 6
7 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}} 7
8 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>)? 8
9 Type Inference {fun {x :?} {+ x 1} } 9
10 Type Inference {fun {x :?} {+ x 1} } T 1 10
11 Type Inference {fun {x :?} {+ x 1} } T 1 num 11
12 Type Inference {fun {x :?} {+ x 1} } T 1 num num T 1 = num 12
13 Type Inference {fun {x :?} {+ x 1} } T 1 num (num num) num T 1 = num 13
14 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 14
15 Type Inference {fun {x :?} {+ x 1} } T 1 num (num num) num T 1 = num {fun {x :?} {if true 1 x} } 15
16 Type Inference {fun {x :?} {+ x 1} } T 1 num (num num) num T 1 = num {fun {x :?} {if true 1 x} } bool 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 17
18 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 18
19 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 19
20 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 20
21 Type Inference: Impossible Cases {fun {x :?} {if x 1 x} } 21
22 Type Inference: Impossible Cases {fun {x :?} {if x 1 x} } T 1 22
23 Type Inference: Impossible Cases {fun {x :?} {if x 1 x} } T 1 num 23
24 Type Inference: Impossible Cases {fun {x :?} {if x 1 x} } T 1 num T 1 24
25 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 25
26 Type Inference: Many Cases {fun {y :?} y} 26
27 Type Inference: Many Cases {fun {y :?} y} T 1 27
28 Type Inference: Many Cases {fun {y :?} y} T 1 (T 1 T 1 ) 28
29 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 29
30 Type Inference: Function Calls {{fun {y :?} y} {fun {x :?} {+ x 1}}} 30
31 Type Inference: Function Calls {{fun {y :?} y} {fun {x :?} {+ x 1}}} (T 1 T 1 ) 31
32 Type Inference: Function Calls {{fun {y :?} y} {fun {x :?} {+ x 1}}} (T 1 T 1 ) (num num) 32
33 Type Inference: Function Calls {{fun {y :?} y} {fun {x :?} {+ x 1}}} (T 1 T 1 ) (num num) T 1 = (num num) 33
34 Type Inference: Function Calls {{fun {y :?} y} {fun {x :?} {+ x 1}}} (T 1 T 1 ) (num num) (num num) T 1 = (num num) 34
35 Type Inference: Function Calls {fun {y :?} {y 7} } 35
36 Type Inference: Function Calls {fun {y :?} {y 7} } T 1 36
37 Type Inference: Function Calls {fun {y :?} {y 7} } T 1 num 37
38 Type Inference: Function Calls {fun {y :?} {y 7} } T 1 num T 2 T 1 = (num T 2 ) 38
39 Type Inference: Function Calls {fun {y :?} {y 7} } T 1 num T 2 T 1 = (num T 2 ) ((num T 2 ) T 2 ) 39
40 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 40
41 Type Inference: Cyclic Equations {fun {x :?} {x x} } 41
42 Type Inference: Cyclic Equations {fun {x :?} {x x} } T 1 42
43 Type Inference: Cyclic Equations {fun {x :?} {x x} } T 1 T 1 43
44 Type Inference: Cyclic Equations T 1 can t be int T 1 can t be bool {fun {x :?} {x x} } T 1 T 1 no type: T 1 can't be (T 1...) Suppose T 1 is (T 2 T 3 ) T 2 must be T 1 So we won t get anywhere! 44
45 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 45
46 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 46
47 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 47
48 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)]) 48
49 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)]) 49
50 Parsing Types (define parse-type : (TE -> Type) (lambda (te) (type-case TE te [numte () (numt)] [arrowte (d r) (arrowt (parse-type d) (parse-type r))] [guesste () (vart (box (none)))]))) 50
51 Type Unification (define (unify! t1 t2 expr) (type-case Type t1 [vart (is1)...] [else (type-case Type t2 [vart (is2) (unify! t2 t1 expr)] [numt () (type-case Type t1 [numt () (values)] [else (type-error expr t1 t2)])] [boolt () (type-case Type t1 [boolt () (values)] [else (type-error expr t1 t2)])] [arrowt (a2 b2) (type-case Type t1 [arrowt (a1 b1) (begin (unify! a1 a2 expr) (unify! b1 b2 expr))] [else (type-error expr t1 t2)])])])) 51
52 Type Unification (define (unify! t1 t2 expr) (type-case Type t1 [vart (is1)...] [else...])) 52
53 Type Unification (define (unify! t1 t2 expr) (type-case Type t1 [vart (is1)...] [else...])) 53
54 Type Unification (define (unify! t1 t2 expr) (type-case Type t1 [vart (is1) (type-case MaybeType (unbox is1) [some (t3) (unify! t3 t2 expr)] [none ()...])] [else...])) 54
55 Type Unification (define (unify! t1 t2 expr) (type-case Type t1 [vart (is1) (type-case MaybeType (unbox is1) [some (t3) (unify! t3 t2 expr)] [none () (local [(define t3 (resolve t2))]...)])] [else...])) 55
56 Type Unification (define (unify! t1 t2 expr) (type-case Type t1 [vart (is1) (type-case MaybeType (unbox is1) [some (t3) (unify! t3 t2 expr)] [none () (local [(define t3 (resolve t2))] (if (eq? t1 t3) (values)...))])] [else...])) 56
57 Type Unification (define (unify! t1 t2 expr) (type-case Type t1 [vart (is1) (type-case MaybeType (unbox is1) [some (t3) (unify! t3 t2 expr)] [none () (local [(define t3 (resolve t2))] (if (eq? t1 t3) (values) (begin (set-box! is1 (some t3)) (values))))])] [else...])) 57
58 Type Unification Helpers (define (resolve t) (type-case Type t [vart (is) (type-case MaybeType (unbox is) [none () t] [some (t2) (resolve t2)])] [else t])) (define (occurs? r t) (type-case Type t [numt () false] [boolt () false] [arrowt (a b) (or (occurs? r a) (occurs? r b))] [vart (is) (or (eq? r t) (type-case MaybeType (unbox is) [none () false] [some (t2) (occurs? r t2)]))])) 58
59 TIFAE Type Checker (define typecheck : (FAE TypeEnv -> Type) (lambda (fae env) (type-case FAE fae... [num (n) (numt)]...))) 59
60 TIFAE Type Checker (define typecheck : (FAE TypeEnv -> Type) (lambda (fae env) (type-case FAE fae... [add (l r)... (typecheck l env) (typecheck r env)...]...))) 60
61 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))]...))) 61
62 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))))]...))) 62
63 TIFAE Type Checker (define typecheck : (FAE TypeEnv -> Type) (lambda (fae env) (type-case FAE fae... [app (fn arg)... (typecheck fn env) (typecheck arg env)...]...))) 63
64 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)...)]...))) 64
65 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))]...))) 65
66 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)...]...))) 66
67 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)...)]...))) 67
68 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)))]...))) 68
69 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)))]...))) 69
Type Declarations. Γ <num> : num [... <id> τ... ] <id> : τ Γ true : bool Γ false : bool Γ e 1 : num Γ e 2 : num Γ. {+ e 1 e 2 } : num
![Type Declarations. Γ <num> : num [... <id> τ... ] <id> : τ Γ true : bool Γ false : bool Γ e 1 : num Γ e 2 : num Γ. {+ e 1 e 2 } : num](/thumbs/81/84354042.jpg "Type Declarations. Γ <num> : num [... <id> τ... ] <id> : τ Γ true : bool Γ false : bool Γ e 1 : num Γ e 2 : num Γ. {+ e 1 e 2 } : num")
Type Declarations Γ : num [... τ... ] : τ Γ 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 Γ[
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
"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
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
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
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
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
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
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
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
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
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.
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
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
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 ::
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
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
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:
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
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
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
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)
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
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";
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
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
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
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
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,
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
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
Functions & First Class Function Values
Functions & First Class Function Values PLAI 1st ed Chapter 4, PLAI 2ed Chapter 5 The concept of a function is itself very close to substitution, and to our with form. Consider the following morph 1 {
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
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
Static Analysis of Dynamically Typed Languages made Easy
Static Analysis of Dynamically Typed Languages made Easy Yin Wang School of Informatics and Computing Indiana University Overview Work done as two internships at Google (2009 summer and 2010 summer) Motivation:
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,
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
OCaml. ML Flow. Complex types: Lists. Complex types: Lists. The PL for the discerning hacker. All elements must have same type.
OCaml The PL for the discerning hacker. ML Flow Expressions (Syntax) Compile-time Static 1. Enter expression 2. ML infers a type Exec-time Dynamic Types 3. ML crunches expression down to a value 4. Value
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
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)
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
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 *)
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
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
Variables and Bindings
Net: Variables Variables and Bindings Q: How to use variables in ML? Q: How to assign to a variable? # let = 2+2;; val : int = 4 let = e;; Bind the value of epression e to the variable Variables and Bindings
CSE341: Programming Languages Lecture 17 Implementing Languages Including Closures. Dan Grossman Autumn 2018
CSE341: Programming Languages Lecture 17 Implementing Languages Including Closures Dan Grossman Autumn 2018 Typical workflow concrete syntax (string) "(fn x => x + x) 4" Parsing Possible errors / warnings
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
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
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
Functional Programming. Pure Functional Programming
Functional Programming Pure Functional Programming Computation is largely performed by applying functions to values. The value of an expression depends only on the values of its sub-expressions (if any).
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
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
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
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
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
Structurally Recursive Descent Parsing. Nils Anders Danielsson (Nottingham) Joint work with Ulf Norell (Chalmers)
Structurally Recursive Descent Parsing Nils Anders Danielsson (Nottingham) Joint work with Ulf Norell (Chalmers) Parser combinators Parser combinator libraries are great! Elegant code. Executable grammars.
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!
Programming Languages
CSE 130 : Fall 2008 Programming Languages Lecture 2: A Crash Course in ML Ranjit Jhala UC San Diego News On webpage: Suggested HW #1, sample for Quiz #1 on Thu PA #1 (due next Fri 10/10) No make-up quizzes
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
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
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
CSE341 Spring 2017, Final Examination June 8, 2017
CSE341 Spring 2017, Final Examination June 8, 2017 Please do not turn the page until 8:30. Rules: The exam is closed-book, closed-note, etc. except for both sides of one 8.5x11in piece of paper. Please
CS61A Midterm 2 Review (v1.1)
Spring 2006 1 CS61A Midterm 2 Review (v1.1) Basic Info Your login: Your section number: Your TA s name: Midterm 2 is going to be held on Tuesday 7-9p, at 1 Pimentel. What will Scheme print? What will the
CSE341 Spring 2017, Final Examination June 8, 2017
CSE341 Spring 2017, Final Examination June 8, 2017 Please do not turn the page until 8:30. Rules: The exam is closed-book, closed-note, etc. except for both sides of one 8.5x11in piece of paper. Please
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
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
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
Discussion 12 The MCE (solutions)
Discussion 12 The MCE (solutions) ;;;;METACIRCULAR EVALUATOR FROM CHAPTER 4 (SECTIONS 4.1.1-4.1.4) of ;;;; STRUCTURE AND INTERPRETATION OF COMPUTER PROGRAMS ;;;from section 4.1.4 -- must precede def of
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
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.
6.037 Lecture 4. Interpretation. What is an interpreter? Why do we need an interpreter? Stages of an interpreter. Role of each part of the interpreter
6.037 Lecture 4 Interpretation Interpretation Parts of an interpreter Meta-circular Evaluator (Scheme-in-scheme!) A slight variation: dynamic scoping Original material by Eric Grimson Tweaked by Zev Benjamin,
Principles of Programming Languages 2017W, Functional Programming
Principles of Programming Languages 2017W, Functional Programming Assignment 3: Lisp Machine (16 points) Lisp is a language based on the lambda calculus with strict execution semantics and dynamic typing.
Midterm 2. CMSC 430 Introduction to Compilers Fall Instructions Total 100. Name: November 19, 2014
Name: Midterm 2 CMSC 430 Introduction to Compilers Fall 2014 November 19, 2014 Instructions This exam contains 10 pages, including this one. Make sure you have all the pages. Write your name on the top
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,
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
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)
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
Overview. Declarative Languages D7012E. Overloading. Overloading Polymorphism Subtyping
Overview Declarative Languages D7012E Lecture 4: The Haskell type system Fredrik Bengtsson / Johan Nordlander Overloading & polymorphism Type classes instances of type classes derived type classes Type
Recap: ML s Holy Trinity
Recap: ML s Holy Trinity 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
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)
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
The Typed Racket Guide
The Typed Racket Guide Version 5.3.6 Sam Tobin-Hochstadt and Vincent St-Amour August 9, 2013 Typed Racket is a family of languages, each of which enforce
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
Programming Languages
CSE 130: Fall 2009 Programming Languages Lecture 2: A Crash Course in ML News On webpage: Suggested HW #1 PA #1 (due next Fri 10/9) Technical issues installing Ocaml - should be resolved soon! Ranjit Jhala
CMSC 330: Organization of Programming Languages. OCaml Imperative Programming
CMSC 330: Organization of Programming Languages OCaml Imperative Programming CMSC330 Spring 2018 1 So Far, Only Functional Programming We haven t given you any way so far to change something in memory
Plan (next 4 weeks) 1. Fast forward. 2. Rewind. 3. Slow motion. Rapid introduction to what s in OCaml. Go over the pieces individually
Plan (next 4 weeks) 1. Fast forward Rapid introduction to what s in OCaml 2. Rewind 3. Slow motion Go over the pieces individually History, Variants Meta Language Designed by Robin Milner @ Edinburgh Language
CSE 413 Midterm, May 6, 2011 Sample Solution Page 1 of 8
Question 1. (12 points) For each of the following, what value is printed? (Assume that each group of statements is executed independently in a newly reset Scheme environment.) (a) (define x 1) (define
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
Typical workflow. CSE341: Programming Languages. Lecture 17 Implementing Languages Including Closures. Reality more complicated
Typical workflow concrete synta (string) "(fn => + ) 4" Parsing CSE341: Programming Languages abstract synta (tree) Lecture 17 Implementing Languages Including Closures Function Constant + 4 Var Var Type
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
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
Programming Languages
CSE 130 : Winter 2013 Programming Languages Lecture 3: Crash Course, Datatypes Ranjit Jhala UC San Diego 1 Story So Far... Simple Expressions Branches Let-Bindings... Today: Finish Crash Course Datatypes
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
CIS 120 Midterm I February 16, 2015 SOLUTIONS
CIS 120 Midterm I February 16, 2015 SOLUTIONS 1 1. Substitution semantics (18 points) Circle the final result of simplifying the following OCaml expressions, or Infinite loop if there is no final answer.
Tail Recursion: Factorial. Begin at the beginning. How does it execute? Tail recursion. Tail recursive factorial. Tail recursive factorial
Begin at the beginning Epressions (Synta) Compile-time Static Eec-time Dynamic Types Values (Semantics) 1. Programmer enters epression 2. ML checks if epression is well-typed Using a precise set of rules,
CSE341 Spring 2016, Final Examination June 6, 2016
CSE341 Spring 2016, Final Examination June 6, 2016 Please do not turn the page until 8:30. Rules: The exam is closed-book, closed-note, etc. except for both sides of one 8.5x11in piece of paper. Please