# Programming Languages Lecture 15: Recursive Types & Subtyping

Size: px
Start display at page:

Transcription

1 CSE 230: Winter 2008 Principles of Programming Languages Lecture 15: Recursive Types & Subtyping Ranjit Jhala UC San Diego News? Formalize first-order type systems Simple types (integers and booleans) Function types (simply typed λ-calculus) Structuredtypes (products and sums) Recursive types (lists, trees) Imperative types (pointers and exceptions) Subtyping Recursive Types (e.g. Lists) What is a list? How to describe using known types? A list of elements of type α (i.e. a α list) is: either empty or it is a pair of a α and a α list α list = unit + (α α list) What does this remind you of? Write t for α list H h i i Hmm another recursive equation: t = unit + (α t)

2 Recursive Types (e.g. Lists) Hmm another recursive equation: t = unit + (α t) Write as t = τ (t) The type variable t occurs in, is bound in τ Introduce recursive type constructor: μt. τ = least fixpoint solution of the equation α list defined as: μt. (unit + α t) Allows unnamed recursive types Manipulating μ Introduce syntactic operations to convert between μt.τ and [μt.τ/t]τ e.g. between αα list and unit + α α list τ ::= t μt.τ e ::= fold μt.τ e unfold μt.τ e Intuition: ii fold μt.τ : takes a τ value, turns it into a μt.τ unfold μt.τ : takes a μt.τ value, turns it into a τ Example with Recursive Types Lists α list = μt. t (unit + α t) nil α = fold α list (injl ()) cons α = λx:α.λl:αλl:α list. fold α list (injr (x, L)) List length function length α = λl:α list. match (unfold α list L) with injl x 0 injr y 1 + length α (snd y) Check that nil α : α list cons α : α α list α list length α : α list int Static Semantics of Recursive Types Syntax directed Γ ` e : μt.τ Γ ` unfold μt.τ e : [μ t.τ/t]τ Γ ` e : [μ t.τ/t]τ Γ ` fold μt.τ e : μt.τ Often, for simplicity, fold/unfold omitted

3 Dynamics of Recursive Types Add a new form of values v ::= fold μt.τ v fold ensures value has recursive type not its unfolding The evaluation rules: e v fold μt.τ e fold μt.τ v e fold μt.τ v unfold μt.τ e v The folding annotations for type checking only can be dropped after type checking Recursive Types in ML Syntactic trick avoids explicit un/fold: combine recursive and union types! datatype t = C 1 of τ 1 C 2 of τ 2... C n of τ n recursive: t can appear in τ i datatype intlist = Nil of unit Cons of int * intlist Programmer writes: Cons (5, l) Compiler reads: fold intlist (injr (5, l)) Programmer writes: match e with Nil... Cons (h, t)... Compiler reads: match unfold intlist e with injl_... injr(h,t)... Encoding CBV λ-calculus in F μ 1 F 1 can t encode non-terminating computations Cannot encode recursion Cannot write the λx.x x (self-application) Recursive types level playing field: Calculus called: F 1 μ typed λ-calculus as expressive as untyped λ-calculus! Convert C B V λ-calculus terms to C B V F 1 μ 1 Untyped programming in F μ 1 e : conversion of the term e to F μ 1 The trick? The type of e is V = μt. t t Conversion rules: Verify that 1. ` e : V x = x λx. e = fold V (λx:v. e) e 1 e 2 = (unfold V e 1 ) e 2 2. e v if and only if e v Non-terminating computation D = (λx:v. (unfold V x) x) (fold V (λx:v. (unfold V x) x)))

4 Formalize first-order type systems Simple types (integers and booleans) Function types (simply typed λ-calculus) Structuredtypes (products and sums) Recursive types (lists, trees) Imperative types (pointers and exceptions) Subtyping Types for Imperative Features So far, pure functional languages Now we look at types for imperative features Types used to characterize non-local effects references, pointers, assignment exceptions Small step semantics : update heap Reference Types For mutable memory cells Syntax (as in ML) e ::=... ref e: τ e 1 := e 2! e τ ::=... τ ref ref e evaluates e allocates new cell stores the value of e returns reference to new cell like malloc + initialization in C, or new in C++ and Java e 1 := e 2 eval e 1 to a memory cell (reference) updates cell s value with value of e 2 Global Effects with Reference Cells Cell can escape static scope where created (λf: int int ref.!(f 5)) (λx: int. ref x) Cell s value must be visible in whole program Result of expr must include changes made to heap side effects must extend the evaluation model!e evaluates e to a memory cell (reference) returns its contents

5 Modeling References heap = mapping from addresses to values h ::= h, a v : τ a Addresses Tag heap cells with their types Types only for static semantics, not evaluation not a part of the implementation program = heap + expression p ::= heap h in e Initial program: heap in e Heap addrs act as bound variables in the expression Allows reuse of local l var. properties for heap addresses e.g., we can rename the address and its occurrences Static Semantics of References Typing rules for expressions: Γ ` e : τ Γ ` ref e : τ ref For programs: Γ ` e : τ ref Γ ` e 1 : τ ref Γ ` e 2 : τ Γ `!e : τ Γ ` e : τ Γ ` heap h in e : τ Where: Γ = a 1 :τ 1 ref,...,a n :τ n ref h = a 1 v 1 : τ 1,, a n : v n :τ n Γ ` e 1 :=e 2 : unit Contextual Semantics for References Addresses are values: v ::=... a New contexts H ::= ref H H 1 := e 2 a 1 := H 2!H No new local reduction rules New global reduction rules propagate effects heap h in H[ref v : τ] heap h, a v : τ in H[a] where a is fresh heap h in H[!a] heap h in H[v] where a v : τ h heap h in H[a := v] heap h[a v] in H[()] where h[a v] = h except cell a v 1 :τ replaced by a v:τ Example with References Consider the evaluation (redex is underlined) heap in (λf:int int ref.!(f 5)) (λx:int. ref x : int) heap in!((λx:int. ref x : int) 5) heap in!(ref 5 : int) heap a = 5 : int in!a heap a = 5 : int in 5 The resulting program has a useless memory cell No references to it in program Equivalent to: heap in 5 Simple way to model garbage collection

6 Formalize first-order type systems Simple types (integers and booleans) Function types (simply typed λ-calculus) Structuredtypes (products and sums) Recursive types (lists, trees) Imperative types (pointers and exceptions) Subtyping Types for Imperative Features So far, pure functional languages Now we look at types for imperative features Types used to characterize non-local effects references, pointers, assignment exceptions Small step semantics : update heap Reference Types For mutable memory cells Syntax (as in ML) e ::=... ref e: τ e 1 := e 2! e τ ::=... τ ref ref e evaluates e allocates new cell stores the value of e returns reference to new cell like malloc + initialization in C, or new in C++ and Java e 1 := e 2 eval e 1 to a memory cell (reference) updates cell s value with value of e 2 Global Effects with Reference Cells Cell can escape static scope where created (λf: int int ref.!(f 5)) (λx: int. ref x) Cell s value must be visible in whole program Result of expr must include changes made to heap side effects must extend the evaluation model (see pdf)!e evaluates e to a memory cell (reference) returns its contents

7 Static Semantics of References Γ ` e : τ Γ ` ref e : τ ref Γ ` e : τ ref Γ `!e : τ Γ ` e 1 : τ ref Γ ` e 2 : τ Γ ` e 1 :=e 2 : unit Modeling References heap = mapping from addresses to values h ::= h, a v : τ a Addresses Tag heap cells with their types Types only for static semantics, not evaluation not a part of the implementation program = heap + expression p ::= heap h in e Initial program: heap in e Heap addrs act as bound variables in the expression Allows reuse of local l var. properties for heap addresses e.g., we can rename the address and its occurrences Static Semantics of References Typing rules for expressions: Γ ` e : τ Γ ` ref e : τ ref For programs: Γ ` e : τ ref Γ ` e 1 : τ ref Γ ` e 2 : τ Γ `!e : τ Γ ` e : τ Γ ` heap h in e : τ Where: Γ = a 1 :τ 1 ref,...,a n :τ n ref h = a 1 v 1 : τ 1,, a n : v n :τ n Γ ` e 1 :=e 2 : unit

8 Contextual Semantics for References Addresses are values: v ::=... a New contexts H ::= ref H H 1 := e 2 a 1 := H 2!H No new local reduction rules New global reduction rules propagate effects heap h in H[ref v : τ] heap h, a v : τ in H[a] where a is fresh heap h in H[!a] heap h in H[v] where a v : τ h heap h in H[a := v] heap h[a v] in H[()] where h[a v] = h except cell a v 1 :τ replaced by a v:τ Example with References Consider the evaluation (redex is underlined) heap in (λf:int int ref.!(f 5)) (λx:int. ref x : int) heap in!((λx:int. ref x : int) 5) heap in!(ref 5 : int) heap a = 5 : int in!a heap a = 5 : int in 5 The resulting program has a useless memory cell No references to it in program Equivalent to: heap in 5 Simple way to model garbage collection Formalize first-order type systems Simple types (integers and booleans) Function types (simply typed λ-calculus) Structuredtypes (products and sums) Recursive types (lists, trees) Imperative types (pointers and exceptions) Subtyping Subtyping Types = Sets of Values Subtyping = Subsets of Values τ < σ means τ is a subtype of σ If τ < σ then, any expression of type τ 1. also has type σ 2. can be used in a context that expects a σ Subtyping is reflexive and transitive

9 Subtyping examples FORTRAN : int < real is well-typed 5 : int, hence 5 : real PASCAL : [1..10] < [0..15] < int Subclasses in object-oriented languages If S is a subclass of C, then inst of S can be used where an inst of C expected Subclassing Subtyping philosophy Can be used = Subsumption Rule of subsumption Formalize the informal subtyping requirement Γ ` e:τ Γ ` e:σ τ < σ If τ < σ then expression of type τ also has type σ Oh look out! What about type safety? If we say that int < (int int) Then we can prove that 5 5 is well typed! Q: How to define subtyping while preserving safety? Defining Subtyping By derivation rules for the judgment τ < σ 1. Start with subtyping on the base types E.g. int < real or nat < int Language-dependent, using types-as-sets 2. Close under reflexivity, transitivity τ 1 <τ 2 τ 2 <τ 3 τ < τ τ 1 < τ 3 3. Build-up subtyping for compound types Subtyping for Pairs τ <σ τ <σ τ τ < σ σ Wherever a σ σ is usable, a τ τ is usable: Consider context H = H [fst ] expecting a σ σ ie i.e. H safely accepts a σ As τ < σ we have H safely accepts a τ If e : τ τ then fst e : τ, thus H safely accepts e : τ τ Case of snd is symmetric

10 Subtyping for Functions Unsafe! τ<σ τ <σ Suppose Γ = f : int bool τ τ < σ σ Rule gives Γ ` f 5.0 : bool 5.0is an invalid argument of f Γ ` f : int bool int < real Γ ` f : real bool bool < bool int bool < real bool Γ ` f 5.0 : bool Γ ` 5.0 : real Eh? int bool not a special case of real bool Works for fewer inputs, can t use instead of Subtyping Functions is: covariant in the result type, Subtype returns fewer outputs contravariant in the argument type Subtype accepts more inputs Informal correctness argument: f : τ τ f expects an argument of type τ can handle special case arg σ < τ No problems executing callee f with arg f returns a value of type τ < σ Special case of σ, caller has no problem with result σ τ<σ< τ τ <σ τ τ < σ σ caller σ σ τ f τ More on Contravariance real real int real real int int int int < real Consider the subtype relationships Subtyping References Unsafe τ < σ τ ref < σ ref Suppose τ < σ Above rule implies x : σ, y : τ ref, f : τ int ` y := x; f (!y) Unsound: f called with σ but defined only on τ Java has covariant arrays!

11 Subtyping References Unsafe: τ < σ σ ref < τ ref Example: assume τ < σ Above rule implies x : σ, y : σ ref, f : τ int ` y := x; f (!y) Unsound: f called on σ but defined d only on τ References are invariant no subtyping for references hence, arrays should be invariant hence, mutable records should be invariant The Limitations of F 1 One function for one type id = λx:τ. x : τ τ sort : (τ τ bool) τ list τ list Need different versions for different τ Only different w.r.t. static typing Same operations performed at runtime Alternatives 1. Circumvent the type system (C, Java,...), 2. Juice up the type system! Polymorphism Polymorphic funs: can be applied to many argument types Varieties of polymorphism : depending di on def. of many 1. subtype (or bounded) polymorphism many = all subtypes of a given type 2. ad-hoc polymorphism many = depends on the function choose behavior at runtime (depending on types, e.g. sizeof) 3. parametric predicative polymorphism many = all monomorphic types 4. parametric impredicative polymorphism many = all types

### 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

### Types for References, Exceptions and Continuations. Review of Subtyping. Γ e:τ τ <:σ Γ e:σ. Annoucements. How s the midterm going?

Types for References, Exceptions and Continuations Annoucements How s the midterm going? Meeting 21, CSCI 5535, Spring 2009 2 One-Slide Summary Review of Subtyping If τ is a subtype of σ then any expression

### Recursive Types and Subtyping

Recursive Types and Subtyping #1 One-Slide Summary Recall: Recursive types (e.g., τ list) make the typed lambda calculus as powerful as the untyped lambda calculus. If τ is a subtype of σ then any expression

### Recursive Types and Subtyping

Recursive Types and Subtyping #1 One-Slide Summary Recursive types (e.g., list) make the typed lambda calculus as powerful as the untyped lambda calculus. If is a subtype of then any expression of type

### 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

### Introduction to System F. Lecture 18 CS 565 4/20/09

Introduction to System F Lecture 18 CS 565 4/20/09 The Limitations of F 1 (simply-typed λ- calculus) In F 1 each function works exactly for one type Example: the identity function id = λx:τ. x : τ τ We

### Harvard School of Engineering and Applied Sciences CS 152: Programming Languages

Harvard School of Engineering and Applied Sciences CS 152: Programming Languages Lecture 14 Tuesday, March 24, 2015 1 Parametric polymorphism Polymorph means many forms. Polymorphism is the ability of

### 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

### Subtyping. Lecture 13 CS 565 3/27/06

Subtyping Lecture 13 CS 565 3/27/06 Polymorphism Different varieties of polymorphism: Parametric (ML) type variables are abstract, and used to encode the fact that the same term can be used in many different

### Programming Languages. Programming with λ-calculus. Lecture 11: Type Systems. Special Hour to discuss HW? if-then-else int

CSE 230: Winter 2010 Principles of Programming Languages Lecture 11: Type Systems News New HW up soon Special Hour to discuss HW? Ranjit Jhala UC San Diego Programming with λ-calculus Encode: bool if-then-else

### Polymorphism. Lecture 19 CS 565 4/17/08

Polymorphism Lecture 19 CS 565 4/17/08 The Limitations of F 1 (simply-typed λ- calculus) In F 1 each function works exactly for one type Example: the identity function id = λx:τ. x : τ τ We need to write

### CSE-321 Programming Languages 2010 Final

Name: Hemos ID: CSE-321 Programming Languages 2010 Final Prob 1 Prob 2 Prob 3 Prob 4 Prob 5 Prob 6 Total Score Max 18 28 16 12 36 40 150 There are six problems on 16 pages, including two work sheets, in

### Second-Order Type Systems

#1 Second-Order Type Systems Homework 5 Summary Student : 37.9704 Student : 44.4466 ORIGINAL : 50.2442 Student : 50.8275 Student : 50.8633 Student : 50.9181 Student : 52.1347 Student : 52.1633 Student

### CSE-321 Programming Languages 2011 Final

Name: Hemos ID: CSE-321 Programming Languages 2011 Final Prob 1 Prob 2 Prob 3 Prob 4 Prob 5 Prob 6 Total Score Max 15 15 10 17 18 25 100 There are six problems on 18 pages in this exam, including one extracredit

### 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

### CSE-505: Programming Languages. Lecture 20.5 Recursive Types. Zach Tatlock 2016

CSE-505: Programming Languages Lecture 20.5 Recursive Types Zach Tatlock 2016 Where are we System F gave us type abstraction code reuse strong abstractions different from real languages (like ML), but

### 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

### Official Survey. Cunning Plan: Focus On Objects. The Need for a Calculus. Object Calculi Summary. Why Not Use λ-calculus for OO?

Modeling and Understanding Object-Oriented Oriented Programming Official Survey Please fill out the Toolkit course survey 40142 CS 655-1 Apr-21-2006 Midnight May-04-2006 9am Why not do it this evening?

### CS-XXX: Graduate Programming Languages. Lecture 17 Recursive Types. Dan Grossman 2012

CS-XXX: Graduate Programming Languages Lecture 17 Recursive Types Dan Grossman 2012 Where are we System F gave us type abstraction code reuse strong abstractions different from real languages (like ML),

### CS 4110 Programming Languages & Logics. Lecture 27 Recursive Types

CS 4110 Programming Languages & Logics Lecture 27 Recursive Types 4 November 2016 Announcements 2 My office hours are at the normal time today but canceled on Monday Guest lecture by Seung Hee Han on Monday

### Mutable References. Chapter 1

Chapter 1 Mutable References In the (typed or untyped) λ-calculus, or in pure functional languages, a variable is immutable in that once bound to a value as the result of a substitution, its contents never

### 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

### We defined congruence rules that determine the order of evaluation, using the following evaluation

CS 4110 Programming Languages and Logics Lectures #21: Advanced Types 1 Overview In this lecture we will extend the simply-typed λ-calculus with several features we saw earlier in the course, including

### 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

### 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,

### 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

### 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

### 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

### CSE 505: Concepts of Programming Languages

CSE 505: Concepts of Programming Languages Dan Grossman Fall 2003 Lecture 6 Lambda Calculus Dan Grossman CSE505 Fall 2003, Lecture 6 1 Where we are Done: Modeling mutation and local control-flow Proving

### 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

### Subtyping and Objects

Subtyping and Objects Massimo Merro 20 November 2017 Massimo Merro Data and Mutable Store 1 / 22 Polymorphism So far, our type systems are very rigid: there is little support to code reuse. Polymorphism

### Lambda Calculi With Polymorphism

Resources: The slides of this lecture were derived from [Järvi], with permission of the original author, by copy & x = 1 let x = 1 in... paste or by selection, annotation, or rewording. [Järvi] is in turn

### 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

### Lecture 13: Subtyping

Lecture 13: Subtyping Polyvios Pratikakis Computer Science Department, University of Crete Type Systems and Programming Languages Pratikakis (CSD) Subtyping CS546, 2018-2019 1 / 15 Subtyping Usually found

### News. Programming Languages. Recap. Recap: Environments. Functions. of functions: Closures. CSE 130 : Fall Lecture 5: Functions and Datatypes

CSE 130 : Fall 2007 Programming Languages News PA deadlines shifted PA #2 now due 10/24 (next Wed) Lecture 5: Functions and Datatypes Ranjit Jhala UC San Diego Recap: Environments Phone book Variables

GADTs meet Subtyping Gabriel Scherer, Didier Rémy Gallium INRIA 2014 Gabriel Scherer, Didier Rémy (Gallium INRIA) GADTs meet Subtyping 2014 1 / 21 A reminder on GADTs GADTs are algebraic data types that

### Subtyping (cont) Lecture 15 CS 565 4/3/08

Subtyping (cont) Lecture 15 CS 565 4/3/08 Formalization of Subtyping Inversion of the subtype relation: If σ

### Functional Languages and Higher-Order Functions

Functional Languages and Higher-Order Functions Leonidas Fegaras CSE 5317/4305 L12: Higher-Order Functions 1 First-Class Functions Values of some type are first-class if They can be assigned to local variables

### CSE-321 Programming Languages 2014 Final

Name: Hemos ID: CSE-321 Programming Languages 2014 Final Problem 1 Problem 2 Problem 3 Problem 4 Problem 5 Problem 6 Total Score Max 15 12 14 14 30 15 100 There are six problems on 12 pages in this exam.

### 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

### 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,

### Lambda Calculi With Polymorphism

Resources: The slides of this lecture were derived from [Järvi], with permission of the original author, by copy & x = 1 let x = 1 in... paste or by selection, annotation, or rewording. [Järvi] is in turn

### CSE-321 Programming Languages 2012 Midterm

Name: Hemos ID: CSE-321 Programming Languages 2012 Midterm Prob 1 Prob 2 Prob 3 Prob 4 Prob 5 Prob 6 Total Score Max 14 15 29 20 7 15 100 There are six problems on 24 pages in this exam. The maximum score

### Programming Languages

CSE 130 : Winter 2009 Programming Languages News PA 2 out, and due Mon 1/26 5pm Lecture 5: Functions and Datatypes t UC San Diego Recap: Environments Phone book Variables = names Values = phone number

### 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

### The Untyped Lambda Calculus

Resources: The slides of this lecture were derived from x = 1 [Järvi], with permission of the original author, by copy & let x = 1 in... paste or by selection, annotation, or rewording. [Järvi] is in turn

### The University of Nottingham SCHOOL OF COMPUTER SCIENCE A LEVEL 4 MODULE, SPRING SEMESTER MATHEMATICAL FOUNDATIONS OF PROGRAMMING ANSWERS

The University of Nottingham SCHOOL OF COMPUTER SCIENCE A LEVEL 4 MODULE, SPRING SEMESTER 2012 2013 MATHEMATICAL FOUNDATIONS OF PROGRAMMING ANSWERS Time allowed TWO hours Candidates may complete the front

### Recap from last time. Programming Languages. CSE 130 : Fall Lecture 3: Data Types. Put it together: a filter function

CSE 130 : Fall 2011 Recap from last time Programming Languages Lecture 3: Data Types Ranjit Jhala UC San Diego 1 2 A shorthand for function binding Put it together: a filter function # let neg = fun f

### Type Systems. Pierce Ch. 3, 8, 11, 15 CSE

Type Systems Pierce Ch. 3, 8, 11, 15 CSE 6341 1 A Simple Language ::= true false if then else 0 succ pred iszero Simple untyped expressions Natural numbers encoded as succ succ

### 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

### Review. CS152: Programming Languages. Lecture 11 STLC Extensions and Related Topics. Let bindings (CBV) Adding Stuff. Booleans and Conditionals

Review CS152: Programming Languages Lecture 11 STLC Extensions and Related Topics e ::= λx. e x ee c v ::= λx. e c (λx. e) v e[v/x] e 1 e 2 e 1 e 2 τ ::= int τ τ Γ ::= Γ,x : τ e 2 e 2 ve 2 ve 2 e[e /x]:

### 1. true / false By a compiler we mean a program that translates to code that will run natively on some machine.

1. true / false By a compiler we mean a program that translates to code that will run natively on some machine. 2. true / false ML can be compiled. 3. true / false FORTRAN can reasonably be considered

### Variables. Substitution

Variables Elements of Programming Languages Lecture 4: Variables, binding and substitution James Cheney University of Edinburgh October 6, 2015 A variable is a symbol that can stand for another expression.

### CSE 505, Fall 2008, Final Examination 11 December Please do not turn the page until everyone is ready.

CSE 505, Fall 2008, Final Examination 11 December 2008 Please do not turn the page until everyone is ready. Rules: The exam is closed-book, closed-note, except for one side of one 8.5x11in piece of paper.

### More Lambda Calculus and Intro to Type Systems

More Lambda Calculus and Intro to Type Systems Plan Heavy Class Participation Thus, wake up! Lambda Calculus How is it related to real life? Encodings Fixed points Type Systems Overview Static, Dyamic

### CSE 505, Fall 2008, Final Examination 11 December Please do not turn the page until everyone is ready.

CSE 505, Fall 2008, Final Examination 11 December 2008 Please do not turn the page until everyone is ready. Rules: The exam is closed-book, closed-note, except for one side of one 8.5x11in piece of paper.

### Foundations. Yu Zhang. Acknowledgement: modified from Stanford CS242

Spring 2013 Foundations Yu Zhang Acknowledgement: modified from Stanford CS242 https://courseware.stanford.edu/pg/courses/317431/ Course web site: http://staff.ustc.edu.cn/~yuzhang/fpl Reading Concepts

### 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

### Lecture 14: Recursive Types

Lecture 14: Recursive Types Polyvios Pratikakis Computer Science Department, University of Crete Type Systems and Programming Languages Pratikakis (CSD) Recursive Types CS546, 2018-2019 1 / 11 Motivation

### Lecture 5: The Untyped λ-calculus

Lecture 5: The Untyped λ-calculus Syntax and basic examples Polyvios Pratikakis Computer Science Department, University of Crete Type Systems and Static Analysis Pratikakis (CSD) Untyped λ-calculus I CS49040,

### CS 565: Programming Languages. Spring 2008 Tu, Th: 16:30-17:45 Room LWSN 1106

CS 565: Programming Languages Spring 2008 Tu, Th: 16:30-17:45 Room LWSN 1106 Administrivia Who am I? Course web page http://www.cs.purdue.edu/homes/peugster/cs565spring08/ Office hours By appointment Main

### COMP 1130 Lambda Calculus. based on slides by Jeff Foster, U Maryland

COMP 1130 Lambda Calculus based on slides by Jeff Foster, U Maryland Motivation Commonly-used programming languages are large and complex ANSI C99 standard: 538 pages ANSI C++ standard: 714 pages Java

### 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

### The Untyped Lambda Calculus

Resources: The slides of this lecture were derived from [Järvi], with permission of the original author, by copy & x = 1 let x = 1 in... paste or by selection, annotation, or rewording. [Järvi] is in turn

### Pierce Ch. 3, 8, 11, 15. Type Systems

Pierce Ch. 3, 8, 11, 15 Type Systems Goals Define the simple language of expressions A small subset of Lisp, with minor modifications Define the type system of this language Mathematical definition using

### 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 assignment for intersections and unions in call-by-value languages

Type assignment for intersections and unions in call-by-value languages Joshua Dunfield and Frank Pfenning Triple Project Carnegie Mellon University 8 April 2003 FOSSACS 03, Warsaw, Poland Type assignment

### Denotational Semantics. Domain Theory

Denotational Semantics and Domain Theory 1 / 51 Outline Denotational Semantics Basic Domain Theory Introduction and history Primitive and lifted domains Sum and product domains Function domains Meaning

### 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

### Combining Programming with Theorem Proving

Combining Programming with Theorem Proving Chiyan Chen and Hongwei Xi Boston University Programming with Theorem Proving p.1/27 Motivation for the Research To support advanced type systems for practical

### 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

### Resources: The slides of this lecture were derived from [Järvi], with permission of the original author, by copy & x = 1 let x = 1 in...

Resources: The slides of this lecture were derived from [Järvi], with permission of the original author, by copy & x = 1 let x = 1 in... paste or by selection, annotation, or rewording. [Järvi] is in turn

### CS 314 Principles of Programming Languages

CS 314 Principles of Programming Languages Lecture 15: Review and Functional Programming Zheng (Eddy) Zhang Rutgers University March 19, 2018 Class Information Midterm exam forum open in Sakai. HW4 and

Advances in Programming Languages Lecture 4: Higher Polymorphism Ian Stark School of Informatics The University of Edinburgh Friday 30 September 2016 Semester 1 Week 2 https://blog.inf.ed.ac.uk/apl16 Topic:

### CSE 505, Fall 2007, Final Examination 10 December Please do not turn the page until everyone is ready.

CSE 505, Fall 2007, Final Examination 10 December 2007 Please do not turn the page until everyone is ready. Rules: The exam is closed-book, closed-note, except for one side of one 8.5x11in piece of paper.

### Part VI. Imperative Functional Programming

Part VI Imperative Functional Programming Chapter 14 Mutable Storage MinML is said to be a pure language because the execution model consists entirely of evaluating an expression for its value. ML is

### 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

### CS153: Compilers Lecture 15: Local Optimization

CS153: Compilers Lecture 15: Local Optimization Stephen Chong https://www.seas.harvard.edu/courses/cs153 Announcements Project 4 out Due Thursday Oct 25 (2 days) Project 5 out Due Tuesday Nov 13 (21 days)

### 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

### 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

### Lambda Calculus and Extensions as Foundation of Functional Programming

Lambda Calculus and Extensions as Foundation of Functional Programming David Sabel and Manfred Schmidt-Schauß 29. September 2015 Lehrerbildungsforum Informatik Last update: 30. September 2015 Overview

### Abstract Interpretation

Abstract Interpretation Ranjit Jhala, UC San Diego April 22, 2013 Fundamental Challenge of Program Analysis How to infer (loop) invariants? Fundamental Challenge of Program Analysis Key issue for any analysis

### 9/23/2014. Why study? Lambda calculus. Church Rosser theorem Completeness of Lambda Calculus: Turing Complete

Dr A Sahu Dept of Computer Science & Engineering IIT Guwahati Why study? Lambda calculus Syntax Evaluation Relationship to programming languages Church Rosser theorem Completeness of Lambda Calculus: Turing

### CSE 130 Programming Languages. Lecture 3: Datatypes. Ranjit Jhala UC San Diego

CSE 130 Programming Languages Lecture 3: Datatypes Ranjit Jhala UC San Diego News? PA #2 (coming tonight) Ocaml-top issues? Pleas post questions to Piazza Recap: ML s Holy Trinity Expressions (Syntax)

### CSE-321 Programming Languages 2010 Midterm

Name: Hemos ID: CSE-321 Programming Languages 2010 Midterm Score Prob 1 Prob 2 Prob 3 Prob 4 Total Max 15 30 35 20 100 1 1 SML Programming [15 pts] Question 1. [5 pts] Give a tail recursive implementation

### Verifying Program Invariants with Refinement Types

Verifying Program Invariants with Refinement Types Rowan Davies and Frank Pfenning Carnegie Mellon University Princeton and Yale Colloquium Talks February, 2001 Acknowledgments: Robert Harper 1 Overview

### 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

### 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

### Arbitrary-rank polymorphism in (GHC) Haskell

Arbitrary-rank polymorphism in (GHC) Haskell CAS 743 Stephen Forrest 20 March 2006 Damas-Milner Type System A Damas-Milner type system (also called Hindley-Milner) is a traditional type system for functional

### 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

### Reminder of the last lecture. Aliasing Issues: Call by reference, Pointer programs. Introducing Aliasing Issues. Home Work from previous lecture

Reminder of the last lecture Aliasing Issues: Call by reference, Pointer programs Claude Marché Cours MPRI 2-36-1 Preuve de Programme 18 janvier 2017 Additional features of the specification language Abstract

### Formal Semantics. Aspects to formalize. Lambda calculus. Approach

Formal Semantics Aspects to formalize Why formalize? some language features are tricky, e.g. generalizable type variables, nested functions some features have subtle interactions, e.g. polymorphism and

### Dependent types and program equivalence. Stephanie Weirich, University of Pennsylvania with Limin Jia, Jianzhou Zhao, and Vilhelm Sjöberg

Dependent types and program equivalence Stephanie Weirich, University of Pennsylvania with Limin Jia, Jianzhou Zhao, and Vilhelm Sjöberg What are dependent types? Types that depend on values of other types

### CS152: Programming Languages. Lecture 7 Lambda Calculus. Dan Grossman Spring 2011

CS152: Programming Languages Lecture 7 Lambda Calculus Dan Grossman Spring 2011 Where we are Done: Syntax, semantics, and equivalence For a language with little more than loops and global variables Now:

### CSc 520 final exam Wednesday 13 December 2000 TIME = 2 hours

NAME s GRADE Prob 1 2 3 4 5 I II III Σ Max 12 12 12 12 12 26 26 26 100(+... ) Score CSc 520 exam Wednesday 13 December 2000 TIME = 2 hours Write all answers ON THIS EXAMINATION, and submit it IN THE ENVELOPE

### 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

### Let Arguments Go First

Let Arguments Go First Ningning Xie and Bruno C. d. S. Oliveira The University of Hong Kong {nnxie,bruno}@cs.hku.hk Abstract. Bi-directional type checking has proved to be an extremely useful and versatile

### 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: