# Programming Languages

Size: px
Start display at page:

Transcription

1 Programming Languages Lambda Calculus and Scheme CSCI-GA Fall 2011

2 λ-calculus invented by Alonzo Church in 1932 as a model of computation basis for functional languages (e.g., Lisp, Scheme, ML, Haskell) typed and untyped variants has syntax and reduction rules 2 / 36

3 Syntax We will discuss the pure, untyped variant of the λ-calculus. The syntax is simple: Shorthands: M ::= λx. M function M M function application x variable We can use parentheses to indicate grouping We can omit parentheses when intent is clear λxyz.m is a shorthand for λx.(λy.(λz.m)) M 1 M 2 M 3 is a shorthand for (M 1 M 2 )M 3 3 / 36

4 Free and bound variables In a term λx.m, the scope of x is M. We say that x is bound in M. Variables that are not bound are free. Example: (λx.(λy.(x(zy))))y The z is free. The last y is free. The x and remaining y are bound. We can perform α-conversion at will: λy.(...y...) α λw.(...w...) 4 / 36

5 β-reduction The main reduction rule in the λ-calculus is function application: (λx.m)n β [x N]M The notation [x N]M means: M, with all bound occurrences of x replaced by N. Restriction: N should not have any free variables which are bound in M. Example: (λx.(λy.(xy)))(λy.y) β λy.(λy.y)y An expression that cannot be β-reduced any further is a normal form. 5 / 36

6 β-reduction The main reduction rule in the λ-calculus is function application: (λx.m)n β [x N]M The notation [x N]M means: M, with all bound occurrences of x replaced by N. Restriction: N should not have any free variables which are bound in M. Example: (λx.(λy.(xy)))(λy.y) β λy.(λy.y)y An expression that cannot be β-reduced any further is a normal form. 6 / 36

7 β-reduction Not everything has a normal form: (λz.zz)(λz.zz) reduces to itself. Application rule can be applied infinitely. 7 / 36

8 Evaluation strategies We have the β-rule, but if we have a complex expression, where should we apply it first? (λx.λy.yxx)((λx.x)(λy.z)) Two popular strategies: normal-order: Reduce the outermost redex first. [x (λx.x)(λy.z)](λy.yxx) β λy.y((λx.x)(λy.z))((λx.x)(λy.z) applicative-order: Arguments to a function evaluated first, from left to right. (λx.λy.yxx)([x (λy.z)]x) β (λx.λy.yxx)((λy.z)) 8 / 36

9 Evaluation strategies Some observations: Some lambda expressions do not terminate when reduced. If a lambda reduction terminates, it terminates to the same reduced expression regardless of reduction order. If a terminating lambda reduction exists, normal order evaluation will terminate. 9 / 36

10 Computational power Fact: The untyped λ-calculus is Turing complete. (Turing, 1937) But how can this be? There are no built-in types other than functions (e.g., no booleans, integers, etc.) There are no loops There are no imperative features There are no recursive definitions 10 / 36

11 Numbers and numerals number: an abstract idea numeral: the representation of a number Example: 15, fifteen, XV, 0F These are different numerals that all represent the same number. Alien numerals: frobnitz frobnitz = wedgleb wedgleb + taksar =? 11 / 36

12 Booleans in the λ-calculus How can a value of true or false be represented in the λ-calculus? Any way we like, as long as we define all the boolean operations correctly. One reasonable definition: true takes two values and returns the first false takes two values and returns the second TRUE λa.λb.a FALSE λa.λb.b IF AND OR NOT λc.λt.λe.(c te) λm.λn.λa.λb.m(nab)b λm.λn.λa.λb.ma(nab) λm.λa.λb.mba 12 / 36

13 Booleans in the λ-calculus Let s try passing TRUE to IF. Evaluate the expression to 1 if TRUE, or 0 otherwise: TRUE λa.λb.a IF λc.λt.λe.(c te) λc.λt.λe.(c t e)(λa.λb.a) 1 0 β λt.λe.((λa.λb.a) t e) 1 0 β λe.((λa.λb.a) 1 e) 0 β ((λa.λb.a) 1 0) β ((λb.1) 0) β 1 13 / 36

14 Arithmetic in the λ-calculus We can represent the number n in the λ-calculus by a function which maps f to f composed with itself n times: f f... f. Some numerals: Some operations: λfx.x λfx.fx λfx.f(fx) λfx.f(f(fx)) ISZERO λn.n(λx.false)true SUCC λnf x.f (nf x) PLUS λmnf x.mf (nf x) MULT λmnf.m(nf) EXP λmn.nm PRED λn.n(λgk.(g 1 )(λu.plus(gk) 1 )k)(λv. 0 ) 0 14 / 36

15 Booleans in the λ-calculus Let s try passing 0 to SUCC: 0 λfx.x SUCC λnf x.f (nf x) λnfx.f(nfx)(λfx.x) β λfx.f((λfx.x) fx) β λfx.f((λx.x) x) β λfx.fx 1 15 / 36

16 Recursion How can we express recursion in the λ-calculus? Example: the factorial function fact(n) if n = 0 then 1 else n fact(n 1) In the λ-calculus, we can start to express this as: fact λn.(iszeron) 1 (MULTn(fact (PREDn))) But we need a way to give the factorial function a name. Idea: Pass in fact as an extra parameter somehow: λfact.λn.(iszeron) 1 (MULTn(fact (PREDn))) We want the fix-point of this function: FIX(f) f(fix(f)) 16 / 36

17 Fix point combinator, rationale Definition of a fix-point operator: FIX(f) f(fix(f)) One step of fact is: λf.λx.(iszerox) 1 (MULTx(f (PREDx))) Call this F. If we apply FIX to this, we get FIX(F)(n) = F (FIX(F))(n) FIX(F)(n) = λx.(iszerox) 1 (MULTx(FIX(F)(PREDx)))(n) FIX(F)(n) = (ISZEROn) 1 (MULTn(FIX(F)(PREDn))) If we rename FIX(F) as fact, we have exactly what we want: fact(n) = (ISZEROn) 1 (MULTn(fact(PREDn))) Conclusion: fact = FIX(F). (But we still need to define FIX.) 17 / 36

18 Fix point combinator, definition There are many fix-point combinators. Here is the simplest, due to Haskell Curry: FIX = λf.(λx.f (xx))(λx.f (xx)) Let s prove that it actually works: But this is exactly g(fix(g))! FIX(g) = (λf.(λx.f (xx))(λx.f (xx)))g β ((λx.g(xx))(λx.g(xx))) β g((λx.g(xx))(λx.g(xx))) 18 / 36

19 Scheme overview related to Lisp, first description in 1975 designed to have clear and simple semantics (unlike Lisp) statically scoped (unlike Lisp) dynamically typed types are associated with values, not variables functional: first-class functions garbage collection simple syntax; lots of parentheses homogeneity of programs and data continuations hygienic macros 19 / 36

20 A sample Scheme session (+ 1 2) 3 (1 2 3) procedure application: expected procedure; given: 1 a reference to undefined identifier: a (quote (+ 1 2)) ; a shorthand is (+ 1 2) (+ 1 2) (car (1 2 3)) 1 (cdr (1 2 3)) (2 3) (cons 1 (2 3)) (1 2 3) 20 / 36

21 Uniform syntax: lists expressions are either atoms or lists atoms are either constants (e.g., numeric, boolean, string) or symbols lists nest, to form full trees syntax is simple because programmer supplies what would otherwise be the internal representation of a program: (+ (* 10 12) (* 7 11)) ; means (10*12 + 7*11) a program is a list: (define (factorial n) (if (eq n 0) 1 (* n (factorial (- n 1)))) 21 / 36

22 List manipulation Three primitives and one constant: car: get head of list cdr: get rest of list cons: prepend an element to a list () null list Add equality (= or eq) and recursion, and you ve got yourself a universal model of computation 22 / 36

23 Rules of evaluation a number evaluates to itself an atom evaluates to its current binding a list is a computation: must be a form (e.g., if, lambda), or first element must evaluate to an operation remaining elements are actual parameters result is the application of the operation to the evaluated actuals 23 / 36

24 Quoting data Q: If every list is a computation, how do we describe data? A: Another primitive: quote (quote ( )) ( ) (quote (Baby needs a new pair of shoes) (Baby needs a new pair of shoes) (this also works) (this also works) 24 / 36

25 List decomposition (car (this is a list of symbols)) this (cdr (this is a list of symbols)) (is a list of symbols) (cdr (this that)) (that) ; a list (cdr (singleton)) () ; the empty list (car ()) car: expects argument of type <pair>; given () 25 / 36

26 List building (cons this (that and the other)) (this that and the other) (cons a ()) (a) useful shortcut: (list a b c d e) (a b c d e) equivalent to: (cons a (cons b (cons c (cons d (cons e ()))))) 26 / 36

27 List decomposition shortcuts Operations like: (car (cdr xs)) (cdr (cdr (cdr ys))) are common. Scheme provides shortcuts: (cadr xs) is (car (cdr xs)) (cdddr xs) is (cdr (cdr (cdr xs))) Up to 4 a s and/or d s can be used. 27 / 36

28 What lists are made of (cons a (b)) (a b) (car (a b)) a (cdr (a b)) (b) a list (cons a b) (a. b) a dotted pair (car (a. b)) a (cdr (a. b)) b A list is a special form of dotted pair, and can be written using a shorthand: (a b c) is shorthand for (a. (b. (c. ())))) We can mix the notations: (a b. c) is shorthand for (a. (b. c)) A list not ending in () is an improper list. 28 / 36

29 Booleans Scheme has true and false values: #t true #f false However, when evaluating a condition (e.g., in an if), any value not equal to #f is considered to be true. 29 / 36

30 Simple control structures Conditional (if condition expr1 expr2) Generalized form (cond (pred1 expr1) (pred2 expr2)... (else exprn)) Evaluate the pred s in order, until one evaluates to true. Then evaluate the corresponding expr. That is the value of the cond expression. if and cond are not regular functions 30 / 36

31 Global definitions define is also special: (define (sqr n) (* n n)) The body is not evaluated; a binding is produced: sqr is bound to the body of the computation: (lambda (n) (* n n)) We can define non-functions too: (define x 15) (sqr x) 225 define can only occur at the top level, and creates global variables. 31 / 36

32 Recursion on lists (define (member elem lis) (cond ((null? lis) #f) ((eq elem (car lis)) lis) (else (member elem (cdr lis))))) Note: every non-false value is true in a boolean context. Convention: return rest of the list, starting from elem, rather than #t. 32 / 36

33 Standard predicates If variables do not have associated types, we need a way to find out what a variable is holding: symbol? number? pair? list? null? zero? Different dialects may have different naming conventions, e.g., symbolp, numberp, etc. 33 / 36

34 Functional arguments (define (map fun lis) (cond ((null? lis) ()) (else (cons (fun (car lis)) (map fun (cdr lis)))))) (map sqr (map sqr ( ))) ( ) 34 / 36

35 Locals Basic let skeleton: (let ((v1 init1) (v2 init2)... (vn initn)) body) To declare locals, use one of the let variants: let : Evaluate all the inits in the current environment; the vs are bound to fresh locations holding the results. let* : Bindings are performed sequentially from left to right, and each binding is done in an environment in which the previous bindings are visible. letrec : The vs are bound to fresh locations holding undefined values, the inits are evaluated in the resulting environment (in some unspecified order), each v is assigned to the result of the corresponding init. This is what we need for mutually recursive functions. 35 / 36

36 Tail recursion A Scheme implementation is properly tail-recursive if it supports an unbounded number of active tail calls. (define (factorial n) (if (zero? n) 1 (* n (factorial (- n 1))))) ; not tail recursive ; stack grows to size n (define (fact-iter prod count var) (if (> count var) prod ( fact-iter (* count prod) ; tail recursive (+ count 1) ; implemented as loop var))) (define (factorial n) (fact-iter 1 1 n)) ; OK 36 / 36

### COP4020 Programming Languages. Functional Programming Prof. Robert van Engelen

COP4020 Programming Languages Functional Programming Prof. Robert van Engelen Overview What is functional programming? Historical origins of functional programming Functional programming today Concepts

### Functional Languages. Hwansoo Han

Functional Languages Hwansoo Han Historical Origins Imperative and functional models Alan Turing, Alonzo Church, Stephen Kleene, Emil Post, etc. ~1930s Different formalizations of the notion of an algorithm

### 11/6/17. Functional programming. FP Foundations, Scheme (2) LISP Data Types. LISP Data Types. LISP Data Types. Scheme. LISP: John McCarthy 1958 MIT

Functional programming FP Foundations, Scheme (2 In Text: Chapter 15 LISP: John McCarthy 1958 MIT List Processing => Symbolic Manipulation First functional programming language Every version after the

### Summer 2017 Discussion 10: July 25, Introduction. 2 Primitives and Define

CS 6A Scheme Summer 207 Discussion 0: July 25, 207 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,

### LECTURE 16. Functional Programming

LECTURE 16 Functional Programming WHAT IS FUNCTIONAL PROGRAMMING? Functional programming defines the outputs of a program as a mathematical function of the inputs. Functional programming is a declarative

### Functional Programming

Functional Programming CS331 Chapter 14 Functional Programming Original functional language is LISP LISt Processing The list is the fundamental data structure Developed by John McCarthy in the 60 s Used

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

### Functional Programming. Big Picture. Design of Programming Languages

Functional Programming Big Picture What we ve learned so far: Imperative Programming Languages Variables, binding, scoping, reference environment, etc What s next: Functional Programming Languages Semantics

### Fall 2017 Discussion 7: October 25, 2017 Solutions. 1 Introduction. 2 Primitives

CS 6A Scheme Fall 207 Discussion 7: October 25, 207 Solutions Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write

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

### Organization of Programming Languages CS3200/5200N. Lecture 11

Organization of Programming Languages CS3200/5200N Razvan C. Bunescu School of Electrical Engineering and Computer Science bunescu@ohio.edu Functional vs. Imperative The design of the imperative languages

### Fall 2018 Discussion 8: October 24, 2018 Solutions. 1 Introduction. 2 Primitives

CS 6A Scheme Fall 208 Discussion 8: October 24, 208 Solutions Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write

### FP Foundations, Scheme

FP Foundations, Scheme In Text: Chapter 15 1 Functional Programming -- Prelude We have been discussing imperative languages C/C++, Java, Fortran, Pascal etc. are imperative languages Imperative languages

### SCHEME 7. 1 Introduction. 2 Primitives COMPUTER SCIENCE 61A. October 29, 2015

SCHEME 7 COMPUTER SCIENCE 61A October 29, 2015 1 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,

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

### SCHEME 8. 1 Introduction. 2 Primitives COMPUTER SCIENCE 61A. March 23, 2017

SCHEME 8 COMPUTER SCIENCE 61A March 2, 2017 1 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,

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

### Scheme. Functional Programming. Lambda Calculus. CSC 4101: Programming Languages 1. Textbook, Sections , 13.7

Scheme Textbook, Sections 13.1 13.3, 13.7 1 Functional Programming Based on mathematical functions Take argument, return value Only function call, no assignment Functions are first-class values E.g., functions

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

### CIS 500 Software Foundations Fall September 25

CIS 500 Software Foundations Fall 2006 September 25 The Lambda Calculus The lambda-calculus If our previous language of arithmetic expressions was the simplest nontrivial programming language, then the

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

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

### Functional Programming. Pure Functional Languages

Functional Programming Pure functional PLs S-expressions cons, car, cdr Defining functions read-eval-print loop of Lisp interpreter Examples of recursive functions Shallow, deep Equality testing 1 Pure

### Spring 2018 Discussion 7: March 21, Introduction. 2 Primitives

CS 61A Scheme Spring 2018 Discussion 7: March 21, 2018 1 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme

### Week 4: Functional Programming

CS320 Principles of Programming Languages Week 4: Functional Programming Jingke Li Portland State University Fall 2017 PSU CS320 Fall 17 Week 4: Functional Programming 1/ 66 Topic List for this Unit Functional

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

### Functional Programming. Pure Functional Languages

Functional Programming Pure functional PLs S-expressions cons, car, cdr Defining functions read-eval-print loop of Lisp interpreter Examples of recursive functions Shallow, deep Equality testing 1 Pure

### Functional Programming Languages (FPL)

Functional Programming Languages (FPL) 1. Definitions... 2 2. Applications... 2 3. Examples... 3 4. FPL Characteristics:... 3 5. Lambda calculus (LC)... 4 6. Functions in FPLs... 7 7. Modern functional

### Lambda Calculus. CS 550 Programming Languages Jeremy Johnson

Lambda Calculus CS 550 Programming Languages Jeremy Johnson 1 Lambda Calculus The semantics of a pure functional programming language can be mathematically described by a substitution process that mimics

### CPS 506 Comparative Programming Languages. Programming Language Paradigm

CPS 506 Comparative Programming Languages Functional Programming Language Paradigm Topics Introduction Mathematical Functions Fundamentals of Functional Programming Languages The First Functional Programming

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

### Imperative languages

Imperative languages Von Neumann model: store with addressable locations machine code: effect achieved by changing contents of store locations instructions executed in sequence, flow of control altered

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

### A Brief Introduction to Scheme (II)

A Brief Introduction to Scheme (II) Philip W. L. Fong pwlfong@cs.uregina.ca Department of Computer Science University of Regina Regina, Saskatchewan, Canada Lists Scheme II p.1/29 Lists Aggregate data

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

### CS 4110 Programming Languages & Logics. Lecture 17 Programming in the λ-calculus

CS 4110 Programming Languages & Logics Lecture 17 Programming in the λ-calculus 10 October 2014 Announcements 2 Foster Office Hours 11-12 Enjoy fall break! Review: Church Booleans 3 We can encode TRUE,

### Introduction to Scheme

How do you describe them Introduction to Scheme Gul Agha CS 421 Fall 2006 A language is described by specifying its syntax and semantics Syntax: The rules for writing programs. We will use Context Free

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

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

Harvard School of Engineering and Applied Sciences CS 152: Programming Languages Tuesday, February 19, 2013 The lambda calculus (or λ-calculus) was introduced by Alonzo Church and Stephen Cole Kleene in

### Introduction to LISP. York University Department of Computer Science and Engineering. York University- CSE V.

Introduction to LISP York University Department of Computer Science and Engineering York University- CSE 3401- V. Movahedi 11_LISP 1 Introduction to LISP Evaluation and arguments S- expressions Lists Numbers

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

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

### Computer Science 203 Programming Languages Fall Lecture 10. Bindings, Procedures, Functions, Functional Programming, and the Lambda Calculus

1 Computer Science 203 Programming Languages Fall 2004 Lecture 10 Bindings, Procedures, Functions, Functional Programming, and the Lambda Calculus Plan Informal discussion of procedures and bindings Introduction

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

### Programming Languages

Programming Languages Tevfik Koşar Lecture - XIII March 2 nd, 2006 1 Roadmap Functional Languages Lambda Calculus Intro to Scheme Basics Functions Bindings Equality Testing Searching 2 1 Functional Languages

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

### Functional Languages. CSE 307 Principles of Programming Languages Stony Brook University

Functional Languages CSE 307 Principles of Programming Languages Stony Brook University http://www.cs.stonybrook.edu/~cse307 1 Historical Origins 2 The imperative and functional models grew out of work

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

### INF 212 ANALYSIS OF PROG. LANGS LAMBDA CALCULUS. Instructors: Crista Lopes Copyright Instructors.

INF 212 ANALYSIS OF PROG. LANGS LAMBDA CALCULUS Instructors: Crista Lopes Copyright Instructors. History Formal mathematical system Simplest programming language Intended for studying functions, recursion

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

### The Lambda Calculus. 27 September. Fall Software Foundations CIS 500. The lambda-calculus. Announcements

CIS 500 Software Foundations Fall 2004 27 September IS 500, 27 September 1 The Lambda Calculus IS 500, 27 September 3 Announcements Homework 1 is graded. Pick it up from Cheryl Hickey (Levine 502). We

### Introduction to lambda calculus Part 3

Introduction to lambda calculus Part 3 Antti-Juhani Kaijanaho 2017-01-27... 1 Untyped lambda calculus... 2 Typed lambda calculi In an untyped lambda calculus extended with integers, it is required that

### Announcements. The current topic: Scheme. Review: BST functions. Review: Representing trees in Scheme. Reminder: Lab 2 is due on Monday at 10:30 am.

The current topic: Scheme! Introduction! Object-oriented programming: Python Functional programming: Scheme! Introduction! Numeric operators, REPL, quotes, functions, conditionals! Function examples, helper

### Imperative, OO and Functional Languages A C program is

Imperative, OO and Functional Languages A C program is a web of assignment statements, interconnected by control constructs which describe the time sequence in which they are to be executed. In Java programming,

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

### SCHEME The Scheme Interpreter. 2 Primitives COMPUTER SCIENCE 61A. October 29th, 2012

SCHEME COMPUTER SCIENCE 6A October 29th, 202 In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs, we will eventually

### 4/19/2018. Chapter 11 :: Functional Languages

Chapter 11 :: Functional Languages Programming Language Pragmatics Michael L. Scott Historical Origins The imperative and functional models grew out of work undertaken by Alan Turing, Alonzo Church, Stephen

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

### An Explicit-Continuation Metacircular Evaluator

Computer Science (1)21b (Spring Term, 2018) Structure and Interpretation of Computer Programs An Explicit-Continuation Metacircular Evaluator The vanilla metacircular evaluator gives a lot of information

### Project 2: Scheme Interpreter

Project 2: Scheme Interpreter CSC 4101, Fall 2017 Due: 12 November 2017 For this project, you will implement a simple Scheme interpreter in C++ or Java. Your interpreter should be able to handle the same

### Functional Programming and λ Calculus. Amey Karkare Dept of CSE, IIT Kanpur

Functional Programming and λ Calculus Amey Karkare Dept of CSE, IIT Kanpur 0 Software Development Challenges Growing size and complexity of modern computer programs Complicated architectures Massively

### Graphical Untyped Lambda Calculus Interactive Interpreter

Graphical Untyped Lambda Calculus Interactive Interpreter (GULCII) Claude Heiland-Allen https://mathr.co.uk mailto:claude@mathr.co.uk Edinburgh, 2017 Outline Lambda calculus encodings How to perform lambda

### Chapter 5: The Untyped Lambda Calculus

Chapter 5: The Untyped Lambda Calculus What is lambda calculus for? Basics: syntax and operational semantics Programming in the Lambda Calculus Formalities (formal definitions) What is Lambda calculus

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

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

### Functional Programming. Functional Programming

2014-06-27 Functional Programming Functional Programming 2014-06-27 Functional Programming 1 Imperative versus Functional Languages attributes of imperative languages: variables, destructive assignment,

### Activity. CSCI 334: Principles of Programming Languages. Lecture 4: Fundamentals II. What is computable? What is computable?

Activity CSCI 334: Principles of Programming Languages Lecture 4: Fundamentals II Write a function firsts that, when given a list of cons cells, returns a list of the left element of each cons. ( (a. b)

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

### Introduction to Functional Programming in Racket. CS 550 Programming Languages Jeremy Johnson

Introduction to Functional Programming in Racket CS 550 Programming Languages Jeremy Johnson 1 Objective To introduce functional programming in racket Programs are functions and their semantics involve

### User-defined Functions. Conditional Expressions in Scheme

User-defined Functions The list (lambda (args (body s to a function with (args as its argument list and (body as the function body. No quotes are needed for (args or (body. (lambda (x (+ x 1 s to the increment

### 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 11 :: Functional Languages

Chapter 11 :: Functional Languages Programming Language Pragmatics Michael L. Scott Copyright 2016 Elsevier 1 Chapter11_Functional_Languages_4e - Tue November 21, 2017 Historical Origins The imperative

### Fundamentals of Artificial Intelligence COMP221: Functional Programming in Scheme (and LISP)

Fundamentals of Artificial Intelligence COMP221: Functional Programming in Scheme (and LISP) Prof. Dekai Wu Department of Computer Science and Engineering The Hong Kong University of Science and Technology

### The Untyped Lambda Calculus

CS738: Advanced Compiler Optimizations The Untyped Lambda Calculus Amey Karkare karkare@cse.iitk.ac.in http://www.cse.iitk.ac.in/~karkare/cs738 Department of CSE, IIT Kanpur Reference Book Types and Programming

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

### Scheme Tutorial. Introduction. The Structure of Scheme Programs. Syntax

Scheme Tutorial Introduction Scheme is an imperative language with a functional core. The functional core is based on the lambda calculus. In this chapter only the functional core and some simple I/O is

### CMSC330. Objects, Functional Programming, and lambda calculus

CMSC330 Objects, Functional Programming, and lambda calculus 1 OOP vs. FP Object-oriented programming (OOP) Computation as interactions between objects Objects encapsulate mutable data (state) Accessed

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

### Chapter 5: The Untyped Lambda Calculus

Chapter 5: The Untyped Lambda Calculus What is lambda calculus for? Basics: syntax and operational semantics Programming in the Lambda Calculus Formalities (formal definitions) What is Lambda calculus

### Chapter 15 Functional Programming Languages

Chapter 15 Functional Programming Languages Fundamentals of Functional Programming Languages Introduction to Scheme A programming paradigm treats computation as the evaluation of mathematical functions.

### Shell CSCE 314 TAMU. Haskell Functions

1 CSCE 314: Programming Languages Dr. Dylan Shell Haskell Functions 2 Outline Defining Functions List Comprehensions Recursion 3 Conditional Expressions As in most programming languages, functions can

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

### CSCE 314 TAMU Fall CSCE 314: Programming Languages Dr. Flemming Andersen. Haskell Functions

1 CSCE 314: Programming Languages Dr. Flemming Andersen Haskell Functions 2 Outline Defining Functions List Comprehensions Recursion 3 Conditional Expressions As in most programming languages, functions

### SCHEME AND CALCULATOR 5b

SCHEME AND CALCULATOR 5b COMPUTER SCIENCE 6A July 25, 203 In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,

### Typed Scheme: Scheme with Static Types

Typed Scheme: Scheme with Static Types Version 4.1.1 Sam Tobin-Hochstadt October 5, 2008 Typed Scheme is a Scheme-like language, with a type system that supports common Scheme programming idioms. Explicit

### Principles of Programming Languages Topic: Functional Programming Professor L. Thorne McCarty Spring 2003

Principles of Programming Languages Topic: Functional Programming Professor L. Thorne McCarty Spring 2003 CS 314, LS, LTM: Functional Programming 1 Scheme A program is an expression to be evaluated (in

### CS 314 Principles of Programming Languages

CS 314 Principles of Programming Languages Lecture 16: Functional Programming Zheng (Eddy Zhang Rutgers University April 2, 2018 Review: Computation Paradigms Functional: Composition of operations on data.

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

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

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

### COMP80 Lambda Calculus Programming Languages Slides Courtesy of Prof. Sam Guyer Tufts University Computer Science History Big ideas Examples:

COMP80 Programming Languages Slides Courtesy of Prof. Sam Guyer Lambda Calculus Formal system with three parts Notation for functions Proof system for equations Calculation rules called reduction Idea:

### Principles of Programming Languages COMP251: Functional Programming in Scheme (and LISP)

Principles of Programming Languages COMP251: Functional Programming in Scheme (and LISP) Prof. Dekai Wu Department of Computer Science and Engineering The Hong Kong University of Science and Technology

### Fundamentals and lambda calculus

Fundamentals and lambda calculus Again: JavaScript functions JavaScript functions are first-class Syntax is a bit ugly/terse when you want to use functions as values; recall block scoping: (function ()

### Notes on Higher Order Programming in Scheme. by Alexander Stepanov

by Alexander Stepanov August 1986 INTRODUCTION Why Scheme? Because it allows us to deal with: 1. Data Abstraction - it allows us to implement ADT (abstact data types) in a very special way. The issue of

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

### Functional programming in LISP

Programming Languages Week 4 Functional programming in LISP College of Information Science and Engineering Ritsumeikan University review of part 3 enumeration of dictionaries you receive a sequence of