Programming Language Concepts: Lecture 19
|
|
|
- Oscar Rogers
- 5 years ago
- Views:
Transcription
1 Programming Language Concepts: Lecture 19 Madhavan Mukund Chennai Mathematical Institute PLC 2009, Lecture 19, 01 April 2009
2 Adding types to λ-calculus The basic λ-calculus is untyped The first functional programming language, LISP, was also untyped Modern languages such as Haskell, ML,...are strongly typed What is the theoretical foundation for such languages?
3 Types in functional programming The structure of types in Haskell Basic types Int, Bool, Float, Char
4 Types in functional programming The structure of types in Haskell Basic types Int, Bool, Float, Char Structured types [Lists] If a is a type, so is [a] [Tuples] If a1, a2,..., ak are types, so is (a1,a2,...,ak)
5 Types in functional programming The structure of types in Haskell Basic types Int, Bool, Float, Char Structured types [Lists] If a is a type, so is [a] [Tuples] If a1, a2,..., ak are types, so is (a1,a2,...,ak) Function types If a, b are types, so is a -> b Function with input a, output b
6 Types in functional programming The structure of types in Haskell Basic types Int, Bool, Float, Char Structured types [Lists] If a is a type, so is [a] [Tuples] If a1, a2,..., ak are types, so is (a1,a2,...,ak) Function types If a, b are types, so is a -> b Function with input a, output b User defined types Data day = Sun Mon Tue Wed Thu Fri Sat Data BTree a = Nil Node (BTree a) a (Btree a)
7 Adding types to λ-calculus... Set Λ of untyped lambda expressions is given by Λ = x λx.m MM where x Var, M,M Λ.
8 Adding types to λ-calculus... Set Λ of untyped lambda expressions is given by Λ = x λx.m MM where x Var, M,M Λ. Add a syntax for basic types When constructing expressions, build up the type from the types of the parts
9 Adding types to λ-calculus... Restrict our language to have just one basic type, written as τ
10 Adding types to λ-calculus... Restrict our language to have just one basic type, written as τ No structured types (lists, tuples,...)
11 Adding types to λ-calculus... Restrict our language to have just one basic type, written as τ No structured types (lists, tuples,...) Function types arise naturally (τ τ, (τ τ) τ τ,...
12 Simply typed λ-calculus A separate set of variables Var s for each type s
13 Simply typed λ-calculus A separate set of variables Var s for each type s Define Λ s, expressions of type s, by mutual recursion
14 Simply typed λ-calculus A separate set of variables Var s for each type s Define Λ s, expressions of type s, by mutual recursion For each type s, every variable x Var s is in Λ s
15 Simply typed λ-calculus A separate set of variables Var s for each type s Define Λ s, expressions of type s, by mutual recursion For each type s, every variable x Var s is in Λ s If M Λ t and x Var s then (λx.m) Λ s t.
16 Simply typed λ-calculus A separate set of variables Var s for each type s Define Λ s, expressions of type s, by mutual recursion For each type s, every variable x Var s is in Λ s If M Λ t and x Var s then (λx.m) Λ s t. If M Λ s t and N Λ s then (MN) Λ t. Note that application must be well typed
17 Simply typed λ-calculus A separate set of variables Var s for each type s Define Λ s, expressions of type s, by mutual recursion For each type s, every variable x Var s is in Λ s If M Λ t and x Var s then (λx.m) Λ s t. If M Λ s t and N Λ s then (MN) Λ t. Note that application must be well typed β rule as usual (λx.m)n β M{x N}
18 Simply typed λ-calculus A separate set of variables Var s for each type s Define Λ s, expressions of type s, by mutual recursion For each type s, every variable x Var s is in Λ s If M Λ t and x Var s then (λx.m) Λ s t. If M Λ s t and N Λ s then (MN) Λ t. Note that application must be well typed β rule as usual (λx.m)n β M{x N} We must have λx.m Λ s t and N Λ s for some types s,t
19 Simply typed λ-calculus A separate set of variables Var s for each type s Define Λ s, expressions of type s, by mutual recursion For each type s, every variable x Var s is in Λ s If M Λ t and x Var s then (λx.m) Λ s t. If M Λ s t and N Λ s then (MN) Λ t. Note that application must be well typed β rule as usual (λx.m)n β M{x N} We must have λx.m Λ s t and N Λ s for some types s,t Moreover, if λx.m Λ s t, then x Var s, so x and N are compatible
20 Simply typed λ-calculus... Extend β to one-step reduction, as usual
21 Simply typed λ-calculus... Extend β to one-step reduction, as usual The reduction relation is Church-Rosser
22 Simply typed λ-calculus... Extend β to one-step reduction, as usual The reduction relation is Church-Rosser In fact, satisifies a much strong property
23 Strong normalization A λ-expression is normalizing if it has a normal form.
24 Strong normalization A λ-expression is normalizing if it has a normal form. strongly normalizing if every reduction sequence leads to a normal form
25 Strong normalization A λ-expression is normalizing if it has a normal form. strongly normalizing if every reduction sequence leads to a normal form Examples (λx.xx)(λx.xx) is not normalizing
26 Strong normalization A λ-expression is normalizing if it has a normal form. strongly normalizing if every reduction sequence leads to a normal form Examples (λx.xx)(λx.xx) is not normalizing (λyz.z)((λx.xx)(λx.xx)) is not strongly normalizing.
27 Strong normalization... A λ-calculus is strongly normalizing if every term in the calculus is strongly normalizing
28 Strong normalization... A λ-calculus is strongly normalizing if every term in the calculus is strongly normalizing Theorem The simply typed λ-calculus is strongly normalizing
29 Strong normalization... A λ-calculus is strongly normalizing if every term in the calculus is strongly normalizing Theorem The simply typed λ-calculus is strongly normalizing Proof intuition Each β-reduction reduces the type complexity of the term Cannot have an infinite sequence of reductions
30 Type checking Syntax of simply typed λ-calculus permits only well-typed terms
31 Type checking Syntax of simply typed λ-calculus permits only well-typed terms Converse question; Given an arbitrary term, is it well-typed?
32 Type checking Syntax of simply typed λ-calculus permits only well-typed terms Converse question; Given an arbitrary term, is it well-typed? For instance, we cannot assign a valid type to f f so f f is not a valid expression in this calculus
33 Type checking Syntax of simply typed λ-calculus permits only well-typed terms Converse question; Given an arbitrary term, is it well-typed? For instance, we cannot assign a valid type to f f so f f is not a valid expression in this calculus Theorem The type-checking problem for the simply typed λ-calculus is decidable
34 Type checking... A term may admit multiple types λx.x can be of type τ τ, (τ τ) (τ τ),...
35 Type checking... A term may admit multiple types λx.x can be of type τ τ, (τ τ) (τ τ),... Principal type scheme of a term M unique type s such that every other valid type is an instance of s Uniformly replace τ s by another type
36 Type checking... A term may admit multiple types λx.x can be of type τ τ, (τ τ) (τ τ),... Principal type scheme of a term M unique type s such that every other valid type is an instance of s Uniformly replace τ s by another type τ τ is principal type scheme of λx.x
37 Type checking... A term may admit multiple types λx.x can be of type τ τ, (τ τ) (τ τ),... Principal type scheme of a term M unique type s such that every other valid type is an instance of s Uniformly replace τ s by another type τ τ is principal type scheme of λx.x Theorem We can always compute the principal type scheme for any well-typed term in the simply typed λ-calculus.
38 Computability with simple types Church numerals are well typed
39 Computability with simple types Church numerals are well typed Translations of basic recursive functions (zero, successor, projection) are well-typed
40 Computability with simple types Church numerals are well typed Translations of basic recursive functions (zero, successor, projection) are well-typed Translation of function composition is well typed
41 Computability with simple types Church numerals are well typed Translations of basic recursive functions (zero, successor, projection) are well-typed Translation of function composition is well typed Translation of primitive recursion is well typed
42 Computability with simple types Church numerals are well typed Translations of basic recursive functions (zero, successor, projection) are well-typed Translation of function composition is well typed Translation of primitive recursion is well typed Translation of minimalization requires elimination of recursive definitions Uses untypable expressions of the form f f
43 Computability with simple types Church numerals are well typed Translations of basic recursive functions (zero, successor, projection) are well-typed Translation of function composition is well typed Translation of primitive recursion is well typed Translation of minimalization requires elimination of recursive definitions Uses untypable expressions of the form f f Minimalization introduces non terminating computations, but we have strong normalization!
44 Computability with simple types Church numerals are well typed Translations of basic recursive functions (zero, successor, projection) are well-typed Translation of function composition is well typed Translation of primitive recursion is well typed Translation of minimalization requires elimination of recursive definitions Uses untypable expressions of the form f f Minimalization introduces non terminating computations, but we have strong normalization! However, there do exist total recursive functions that are not primitive recursive e.g. Ackermann s function
45 Polymorphism Simply typed λ-calculus has explicit types
46 Polymorphism Simply typed λ-calculus has explicit types Languages like Haskell have polymorphic types Compare id :: a -> a with λx.x : τ τ
47 Polymorphism Simply typed λ-calculus has explicit types Languages like Haskell have polymorphic types Compare id :: a -> a with λx.x : τ τ Second-order polymorhpic typed lambda calculus (System F) Jean-Yves Girard John Reynolds
48 System F Add type variables, a, b,...
49 System F Add type variables, a, b,... Use i, j,...to denote concrete types
50 System F Add type variables, a, b,... Use i, j,...to denote concrete types Type schemes s ::= a i s s a.s
51 System F Syntax of second order polymorphic lambda calculus Every variable and (type) constant is a term.
52 System F Syntax of second order polymorphic lambda calculus Every variable and (type) constant is a term. If M is a term, x is a variable and s is a type scheme, then (λx s.m) is a term.
53 System F Syntax of second order polymorphic lambda calculus Every variable and (type) constant is a term. If M is a term, x is a variable and s is a type scheme, then (λx s.m) is a term. If M and N are terms, so is (MN). Function application does not enforce type check
54 System F Syntax of second order polymorphic lambda calculus Every variable and (type) constant is a term. If M is a term, x is a variable and s is a type scheme, then (λx s.m) is a term. If M and N are terms, so is (MN). Function application does not enforce type check If M is a term and a is a type variable, then (Λa.M) is a term. Type abstraction
55 System F Syntax of second order polymorphic lambda calculus Every variable and (type) constant is a term. If M is a term, x is a variable and s is a type scheme, then (λx s.m) is a term. If M and N are terms, so is (MN). Function application does not enforce type check If M is a term and a is a type variable, then (Λa.M) is a term. Type abstraction If M is a term and s is a type scheme, (Ms) is a term. Type application
56 System F Example A polymorphic identity function Λa.λx a.x
57 System F Example A polymorphic identity function Λa.λx a.x Two β rules, for two types of abstraction
58 System F Example A polymorphic identity function Λa.λx a.x Two β rules, for two types of abstraction (λx s.m)n β M{x N}
59 System F Example A polymorphic identity function Λa.λx a.x Two β rules, for two types of abstraction (λx s.m)n β M{x N} (Λa.M)s β M{a s}
60 System F System F is also strongly normalizing
61 System F System F is also strongly normalizing...but type inference is undecidable! Given an arbitrary term, can it be assigned a sensible type?
62 Type inference in System F Type of a complex expression can be deduced from types assigned to its parts
63 Type inference in System F Type of a complex expression can be deduced from types assigned to its parts To formalize this, define a relation A M : s A is list {xi : t i } of type assumptions for variables Under the assumptions in A, the expression M has type s.
64 Type inference in System F Type of a complex expression can be deduced from types assigned to its parts To formalize this, define a relation A M : s A is list {xi : t i } of type assumptions for variables Under the assumptions in A, the expression M has type s. Inference rules to derive type judgments of the form A M : s
65 Type inference in System F Notation If A is a list of assumptions, A + {x : s} is the list where Assumption for x in A (if any) is overridden by the new assumption x : s. For any variable y x, assumption does not change
66 Type inference in System F Notation If A is a list of assumptions, A + {x : s} is the list where Assumption for x in A (if any) is overridden by the new assumption x : s. For any variable y x, assumption does not change A + {x : s} M : t A (λx s.m) : s t
67 Type inference in System F Notation If A is a list of assumptions, A + {x : s} is the list where Assumption for x in A (if any) is overridden by the new assumption x : s. For any variable y x, assumption does not change A + {x : s} M : t A (λx s.m) : s t A M : s t, A N : s A (MN) : t
68 Type inference in System F Notation If A is a list of assumptions, A + {x : s} is the list where Assumption for x in A (if any) is overridden by the new assumption x : s. For any variable y x, assumption does not change A + {x : s} M : t A (λx s.m) : s t A M : s t, A N : s A (MN) : t A M : s A (Λa.M) : a.s
69 Type inference in System F Notation If A is a list of assumptions, A + {x : s} is the list where Assumption for x in A (if any) is overridden by the new assumption x : s. For any variable y x, assumption does not change A + {x : s} M : t A (λx s.m) : s t A M : s t, A N : s A (MN) : t A M : s A (Λa.M) : a.s A M : a.s A Mt : s{a t}
70 Type inference in System F Example Deriving the type of polymorphic identity function Λa.λx a.x
71 Type inference in System F Example Deriving the type of polymorphic identity function Λa.λx a.x x : a x : a
72 Type inference in System F Example Deriving the type of polymorphic identity function Λa.λx a.x x : a x : a (λx a.x) : a a
73 Type inference in System F Example Deriving the type of polymorphic identity function Λa.λx a.x x : a x : a (λx a.x) : a a (Λa.λx a.x) : a.a a
74 Type inference in System F Type inference is undecidable for System F
75 Type inference in System F Type inference is undecidable for System F... but we have type-checking algorithms for Haskell, ML,...!
76 Type inference in System F Type inference is undecidable for System F... but we have type-checking algorithms for Haskell, ML,...! Haskell etc use a restricted version of polymorphic types All types are universally quantified at the top level
77 Type inference in System F Type inference is undecidable for System F... but we have type-checking algorithms for Haskell, ML,...! Haskell etc use a restricted version of polymorphic types All types are universally quantified at the top level When we write map :: (a -> b) -> [a] -> [b], we mean that the type is map :: a,b. (a b) [a] [b]
78 Type inference in System F Type inference is undecidable for System F... but we have type-checking algorithms for Haskell, ML,...! Haskell etc use a restricted version of polymorphic types All types are universally quantified at the top level When we write map :: (a -> b) -> [a] -> [b], we mean that the type is map :: a,b. (a b) [a] [b] Also called shallow typing
79 Type inference in System F Type inference is undecidable for System F... but we have type-checking algorithms for Haskell, ML,...! Haskell etc use a restricted version of polymorphic types All types are universally quantified at the top level When we write map :: (a -> b) -> [a] -> [b], we mean that the type is map :: a,b. (a b) [a] [b] Also called shallow typing System F permits deep typing a. [( b. a b) a a]
Logic Programming: Lecture 1
Logic Programming: Lecture 1 Madhavan Mukund Chennai Mathematical Institute madhavan@cmi.ac.in PLC, 3 April 2017 Logic programming Programming with relations Variables Names starting with a capital letter
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
CSE 3302 Programming Languages Lecture 8: Functional Programming
CSE 3302 Programming Languages Lecture 8: Functional Programming (based on the slides by Tim Sheard) Leonidas Fegaras University of Texas at Arlington CSE 3302 L8 Spring 2011 1 Functional Programming Languages
Introduction to Lambda Calculus. Lecture 7 CS /08/09
Introduction to Lambda Calculus Lecture 7 CS 565 02/08/09 Lambda Calculus So far, we ve explored some simple but non-interesting languages language of arithmetic expressions IMP (arithmetic + while loops)
Lecture slides & distribution files:
Type Theory Lecture slides & distribution files: http://www.cs.rhul.ac.uk/home/zhaohui/ttlectures.html Zhaohui Luo Department of Computer Science Royal Holloway, University of London April 2011 2 Type
Haskell 98 in short! CPSC 449 Principles of Programming Languages
Haskell 98 in short! n Syntax and type inferencing similar to ML! n Strongly typed! n Allows for pattern matching in definitions! n Uses lazy evaluation" F definition of infinite lists possible! n Has
Lambda Calculus. Variables and Functions. cs3723 1
Lambda Calculus Variables and Functions cs3723 1 Lambda Calculus Mathematical system for functions Computation with functions Captures essence of variable binding Function parameters and substitution Can
λ calculus is inconsistent
Content Rough timeline COMP 4161 NICTA Advanced Course Advanced Topics in Software Verification Gerwin Klein, June Andronick, Toby Murray λ Intro & motivation, getting started [1] Foundations & Principles
Lexicografie computationala Feb., 2012
Lexicografie computationala Feb., 2012 Anca Dinu University of Bucharest Introduction When we construct meaning representations systematically, we integrate information from two different sources: 1. The
Programming Language Concepts: Lecture 22
Programming Language Concepts: Lecture 22 Madhavan Mukund Chennai Mathematical Institute madhavan@cmi.ac.in http://www.cmi.ac.in/~madhavan/courses/pl2009 PLC 2009, Lecture 22, 15 April 2009 Logic programming
Introduction to the Lambda Calculus. Chris Lomont
Introduction to the Lambda Calculus Chris Lomont 2010 2011 2012 www.lomont.org Leibniz (1646-1716) Create a universal language in which all possible problems can be stated Find a decision method to solve
A Quick Overview. CAS 701 Class Presentation 18 November Department of Computing & Software McMaster University. Church s Lambda Calculus
A Quick Overview CAS 701 Class Presentation 18 November 2008 Lambda Department of Computing & Software McMaster University 1.1 Outline 1 2 3 Lambda 4 5 6 7 Type Problem Lambda 1.2 Lambda calculus is a
Programming Language Concepts: Lecture 14
Programming Language Concepts: Lecture 14 Madhavan Mukund Chennai Mathematical Institute madhavan@cmi.ac.in http://www.cmi.ac.in/~madhavan/courses/pl2009 PLC 2009, Lecture 14, 11 March 2009 Function programming
Introduction to Lambda Calculus. Lecture 5 CS 565 1/24/08
Introduction to Lambda Calculus Lecture 5 CS 565 1/24/08 Lambda Calculus So far, we ve explored some simple but non-interesting languages language of arithmetic expressions IMP (arithmetic + while loops)
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
Lambda Calculus. Lecture 4 CS /26/10
Lambda Calculus Lecture 4 CS 565 10/26/10 Pure (Untyped) Lambda Calculus The only value is a function Variables denote functions Functions always take functions as arguments Functions always return functions
Introduction to the Lambda Calculus
Introduction to the Lambda Calculus Overview: What is Computability? Church s Thesis The Lambda Calculus Scope and lexical address The Church-Rosser Property Recursion References: Daniel P. Friedman et
One of a number of approaches to a mathematical challenge at the time (1930): Constructibility
λ Calculus Church s λ Calculus: Brief History One of a number of approaches to a mathematical challenge at the time (1930): Constructibility (What does it mean for an object, e.g. a natural number, to
Less naive type theory
Institute of Informatics Warsaw University 26 May 2007 Plan 1 Syntax of lambda calculus Why typed lambda calculi? 2 3 Syntax of lambda calculus Why typed lambda calculi? origins in 1930s (Church, Curry)
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
Recursive Definitions, Fixed Points and the Combinator
Recursive Definitions, Fixed Points and the Combinator Dr. Greg Lavender Department of Computer Sciences University of Texas at Austin Recursive Self-Reference Recursive self-reference occurs regularly
CMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages Lambda Calculus CMSC 330 1 Programming Language Features Many features exist simply for convenience Multi-argument functions foo ( a, b, c ) Use currying
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
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,
Programming Language Features. CMSC 330: Organization of Programming Languages. Turing Completeness. Turing Machine.
CMSC 330: Organization of Programming Languages Lambda Calculus Programming Language Features Many features exist simply for convenience Multi-argument functions foo ( a, b, c ) Ø Use currying or tuples
CMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages Lambda Calculus CMSC 330 1 Programming Language Features Many features exist simply for convenience Multi-argument functions foo ( a, b, c ) Ø Use currying
COMP 4161 NICTA Advanced Course. Advanced Topics in Software Verification. Toby Murray, June Andronick, Gerwin Klein
COMP 4161 NICTA Advanced Course Advanced Topics in Software Verification Toby Murray, June Andronick, Gerwin Klein λ 1 Last time... λ calculus syntax free variables, substitution β reduction α and η conversion
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
11/6/17. Outline. FP Foundations, Scheme. Imperative Languages. Functional Programming. Mathematical Foundations. Mathematical Foundations
Outline FP Foundations, Scheme In Text: Chapter 15 Mathematical foundations Functional programming λ-calculus LISP Scheme 2 Imperative Languages We have been discussing imperative languages C/C++, Java,
Last class. CS Principles of Programming Languages. Introduction. Outline
Last class CS6848 - Principles of Programming Languages Principles of Programming Languages V. Krishna Nandivada IIT Madras Interpreters A Environment B Cells C Closures D Recursive environments E Interpreting
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
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
COSE212: Programming Languages. Lecture 3 Functional Programming in OCaml
COSE212: Programming Languages Lecture 3 Functional Programming in OCaml Hakjoo Oh 2017 Fall Hakjoo Oh COSE212 2017 Fall, Lecture 3 September 18, 2017 1 / 44 Why learn ML? Learning ML is a good way of
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!
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
Functions as data. Massimo Merro. 9 November Massimo Merro The Lambda language 1 / 21
Functions as data Massimo Merro 9 November 2011 Massimo Merro The Lambda language 1 / 21 The core of sequential programming languages In the mid 1960s, Peter Landin observed that a complex programming
More Untyped Lambda Calculus & Simply Typed Lambda Calculus
Concepts in Programming Languages Recitation 6: More Untyped Lambda Calculus & Simply Typed Lambda Calculus Oded Padon & Mooly Sagiv (original slides by Kathleen Fisher, John Mitchell, Shachar Itzhaky,
Formal Systems and their Applications
Formal Systems and their Applications Dave Clarke (Dave.Clarke@cs.kuleuven.be) Acknowledgment: these slides are based in part on slides from Benjamin Pierce and Frank Piessens 1 Course Overview Introduction
λ calculus Function application Untyped λ-calculus - Basic Idea Terms, Variables, Syntax β reduction Advanced Formal Methods
Course 2D1453, 2006-07 Advanced Formal Methods Lecture 2: Lambda calculus Mads Dam KTH/CSC Some material from B. Pierce: TAPL + some from G. Klein, NICTA Alonzo Church, 1903-1995 Church-Turing thesis First
An Introduction to the Lambda Calculus
Department of Computer Science Australian National University COMP3610 Principles of Programming Languages An Introduction to the Lambda Calculus Clem Baker-Finch August 13, 2013 Contents 1 Motivation
> module Lambda where > import Data.List -- I need some standard list functions
Lecture 9 Lambda Calculus We now look at lambda calculus, the theoretical stuff that underlies functional programming. It was introduced by Alonzo Church to formalise two key concepts when dealing with
Introduction to the λ-calculus
Announcements Prelim #2 issues: o Problem 5 grading guide out shortly o Problem 3 (hashing) issues Will be on final! Friday RDZ office hours are 11-12 not 1:30-2:30 1 Introduction to the λ-calculus Today
VU Semantik von Programmiersprachen
VU Semantik von Programmiersprachen Agata Ciabattoni Institute für Computersprachen, Theory and Logic group (agata@logic.at) (A gentle) Introduction to λ calculus p. 1 Why shoud I studyλcalculus? p. 2
Chapter 15. Functional Programming. Topics. Currying. Currying: example. Currying: example. Reduction
Topics Chapter 15 Functional Programming Reduction and Currying Recursive definitions Local definitions Type Systems Strict typing Polymorphism Classes Booleans Characters Enumerations Tuples Strings 2
CITS3211 FUNCTIONAL PROGRAMMING
CITS3211 FUNCTIONAL PROGRAMMING 9. The λ calculus Summary: This lecture introduces the λ calculus. The λ calculus is the theoretical model underlying the semantics and implementation of functional programming
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
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
What does my program mean?
September 16, 2015 L02-1 What does my program mean? Armando Solar Lezama Computer Science and Artificial Intelligence Laboratory M.I.T. Adapted from Arvind 2010. Used with permission. September 16, 2015
CS 6110 S14 Lecture 1 Introduction 24 January 2014
CS 6110 S14 Lecture 1 Introduction 24 January 2014 1 Introduction What is a program? Is it just something that tells the computer what to do? Yes, but there is much more to it than that. The basic expressions
Lambda Calculus. Concepts in Programming Languages Recitation 6:
Concepts in Programming Languages Recitation 6: Lambda Calculus Oded Padon & Mooly Sagiv (original slides by Kathleen Fisher, John Mitchell, Shachar Itzhaky, S. Tanimoto ) Reference: Types and Programming
CS 11 Haskell track: lecture 1
CS 11 Haskell track: lecture 1 This week: Introduction/motivation/pep talk Basics of Haskell Prerequisite Knowledge of basic functional programming e.g. Scheme, Ocaml, Erlang CS 1, CS 4 "permission 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
Grades. 10% - participation & exercises. 90% - term paper
Termination Typing Grades 10% - participation & exercises 90% - term paper Alonzo Church (1903-1995) invented lambda calculus (1932) first programminglanguage researcher (sans computers) Turing s advisor
Polymorphism and System-F (OV)
Polymorphism and System-F (OV) Theorie der Programmierung SoSe 2014 FAU the occurrence of something in several different forms Polymorphism? Polymorphic systems Type systems that allow a single piece of
Lecture 3: Typed Lambda Calculus and Curry-Howard
Lecture 3: Typed Lambda Calculus and Curry-Howard H. Geuvers Radboud University Nijmegen, NL 21st Estonian Winter School in Computer Science Winter 2016 H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus
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 ::
Type Systems Winter Semester 2006
Type Systems Winter Semester 2006 Week 4 November 8 November 15, 2006 - version 1.1 The Lambda Calculus The lambda-calculus If our previous language of arithmetic expressions was the simplest nontrivial
5. Introduction to the Lambda Calculus. Oscar Nierstrasz
5. Introduction to the Lambda Calculus Oscar Nierstrasz Roadmap > What is Computability? Church s Thesis > Lambda Calculus operational semantics > The Church-Rosser Property > Modelling basic programming
Lecture Notes on Data Representation
Lecture Notes on Data Representation 15-814: Types and Programming Languages Frank Pfenning Lecture 9 Tuesday, October 2, 2018 1 Introduction In this lecture we ll see our type system in action. In particular
CMSC 330: Organization of Programming Languages. Lambda Calculus Encodings
CMSC 330: Organization of Programming Languages Lambda Calculus Encodings CMSC330 Spring 2018 1 The Power of Lambdas Despite its simplicity, the lambda calculus is quite expressive: it is Turing complete!
CMSC 336: Type Systems for Programming Languages Lecture 5: Simply Typed Lambda Calculus Acar & Ahmed January 24, 2008
CMSC 336: Type Systems for Programming Languages Lecture 5: Simply Typed Lambda Calculus Acar & Ahmed January 24, 2008 Contents 1 Solution to the Exercise 1 1.1 Semantics for lambda calculus.......................
Functional Programming and Modeling
Chapter 2 2. Functional Programming and Modeling 2.0 2. Functional Programming and Modeling 2.0 Overview of Chapter Functional Programming and Modeling 2. Functional Programming and Modeling 2.1 Overview
M. Snyder, George Mason University LAMBDA CALCULUS. (untyped)
1 LAMBDA CALCULUS (untyped) 2 The Untyped Lambda Calculus (λ) Designed by Alonzo Church (1930s) Turing Complete (Turing was his doctoral student!) Models functions, always as 1-input Definition: terms,
Fundamentals and lambda calculus. Deian Stefan (adopted from my & Edward Yang s CSE242 slides)
Fundamentals and lambda calculus Deian Stefan (adopted from my & Edward Yang s CSE242 slides) Logistics Assignments: Programming assignment 1 is out Homework 1 will be released tomorrow night Podcasting:
CSC312 Principles of Programming Languages : Functional Programming Language. Copyright 2006 The McGraw-Hill Companies, Inc.
CSC312 Principles of Programming Languages : Functional Programming Language Overview of Functional Languages They emerged in the 1960 s with Lisp Functional programming mirrors mathematical functions:
dynamically typed dynamically scoped
Reference Dynamically Typed Programming Languages Part 1: The Untyped λ-calculus Jim Royer CIS 352 April 19, 2018 Practical Foundations for Programming Languages, 2/e, Part VI: Dynamic Types, by Robert
CMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages Lambda Calculus Encodings CMSC 330 Summer 2017 1 The Power of Lambdas Despite its simplicity, the lambda calculus is quite expressive: it is Turing complete!
CMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages Lambda Calculus Encodings CMSC 330 Spring 2017 1 Review A lambda calculus expression is defined as e ::= x variable λx.e abstraction (fun def) e e application
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:
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";
Theory and Implementation of a Functional Programming Language
Rose-Hulman Undergraduate Mathematics Journal Volume 1 Issue 2 Article 3 Theory and Implementation of a Functional Programming Language Ari Lamstein University of Michigan Follow this and additional works
Lecture 9: More Lambda Calculus / Types
Lecture 9: More Lambda Calculus / Types CSC 131 Spring, 2019 Kim Bruce Pure Lambda Calculus Terms of pure lambda calculus - M ::= v (M M) λv. M - Impure versions add constants, but not necessary! - Turing-complete
- M ::= v (M M) λv. M - Impure versions add constants, but not necessary! - Turing-complete. - true = λ u. λ v. u. - false = λ u. λ v.
Pure Lambda Calculus Lecture 9: More Lambda Calculus / Types CSC 131 Spring, 2019 Kim Bruce Terms of pure lambda calculus - M ::= v (M M) λv. M - Impure versions add constants, but not necessary! - Turing-complete
Type Inference. COS 326 David Walker Princeton University
Type Inference COS 326 David Walker Princeton University slides copyright 2017 David Walker permission granted to reuse these slides for non-commercial educafonal purposes 2 Midterm Exam Wed Oct 25, 2017
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
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
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
3.1 λ-calculus: Syntax
3 The Lambda Calculus The Lambda calculus, or λ-calculus, is a model of computation based on the idea that algorithms can be seen as mathematical functions mapping inputs to outputs. It was introduced
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,
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
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
CPS Conversion. Di Zhao.
CPS Conversion Di Zhao zhaodi01@mail.ustc.edu.cn This is the first assignment of the course - Advanced Topics in Software Technologies in the 2014-2015 academic year. During this course, we will explore
Polymorphism and Type Inference
Polymorphism and Type Inference Volker Stolz stolz@ifi.uio.no INF 3110-2008 Department of Informatics University of Oslo Initially by Gerardo Schneider. Based on John C. Mitchell s slides (Stanford U.)
λ-calculus Lecture 1 Venanzio Capretta MGS Nottingham
λ-calculus Lecture 1 Venanzio Capretta MGS 2018 - Nottingham Table of contents 1. History of λ-calculus 2. Definition of λ-calculus 3. Data Structures 1 History of λ-calculus Hilbert s Program David Hilbert
Functional Programming
Functional Programming COMS W4115 Prof. Stephen A. Edwards Spring 2003 Columbia University Department of Computer Science Original version by Prof. Simon Parsons Functional vs. Imperative Imperative programming
n λxy.x n y, [inc] [add] [mul] [exp] λn.λxy.x(nxy) λmn.m[inc]0 λmn.m([add]n)0 λmn.n([mul]m)1
![n λxy.x n y, [inc] [add] [mul] [exp] λn.λxy.x(nxy) λmn.m[inc]0 λmn.m([add]n)0 λmn.n([mul]m)1](/thumbs/82/86469119.jpg "n λxy.x n y, [inc] [add] [mul] [exp] λn.λxy.x(nxy) λmn.m[inc]0 λmn.m([add]n)0 λmn.n([mul]m)1")
LAMBDA CALCULUS 1. Background λ-calculus is a formal system with a variety of applications in mathematics, logic, and computer science. It examines the concept of functions as processes, rather than the
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
An Introduction to Polymorphic Lambda Calculus with Subtyping.
Vrije Universiteit Brussel Faculteit Wetenschappen An Introduction to Polymorphic Lambda Calculus with Subtyping. Kim Mens (e-mail: kimmens@is1.vub.ac.be) Techreport vub-tinf-tr-94-01 October 16, 1994
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
Untyped Lambda Calculus
Advanced Topics in Programming Languages Untyped Lambda Calculus Oded Padon & Mooly Sagiv (original slides by Kathleen Fisher, John Mitchell, Shachar Itzhaky, S. Tanimoto ) Reference: Types and Programming
1.3. Conditional expressions To express case distinctions like
Introduction Much of the theory developed in the underlying course Logic II can be implemented in a proof assistant. In the present setting this is interesting, since we can then machine extract from a
Exercise 1 ( = 22 points)
1 Exercise 1 (4 + 3 + 4 + 5 + 6 = 22 points) The following data structure represents polymorphic lists that can contain values of two types in arbitrary order: data DuoList a b = C a (DuoList a b) D b
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
Lecture Notes on Program Equivalence
Lecture Notes on Program Equivalence 15-312: Foundations of Programming Languages Frank Pfenning Lecture 24 November 30, 2004 When are two programs equal? Without much reflection one might say that two
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
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
10.6 Theoretical Foundations
10 Functional Languages 10.6 Theoretical Foundations EXAMPLE 10.44 Functions as mappings Mathematically,a function is a single-valued mapping: it associates every element in one set (the domain) with (at
CSE 505. Lecture #9. October 1, Lambda Calculus. Recursion and Fixed-points. Typed Lambda Calculi. Least Fixed Point
Lambda Calculus CSE 505 Lecture #9 October 1, 2012 Expr ::= Var λ Var. Expr (Expr Expr) Key Concepts: Bound and Free Occurrences Substitution, Reduction Rules: α, β, η Confluence and Unique Normal Form
lambda calculus History 11/28/13 Jianguo Lu A formal system designed to inves:gate func:on defini:on, func:on applica:on, and recursion.
lambda calculus Jianguo Lu 1 History Lambda calculus A formal system designed to inves:gate func:on defini:on, func:on applica:on, and recursion. Introduced by Alonzo Church in 1930s. The calculus can
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