# 1.3. Conditional expressions To express case distinctions like

Size: px
Start display at page:

Transcription

1 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 formal proof its computational content, in the form of a term t realizing the proven formula A (the specification ). Since we can also formalize the proof of the soundness theorem, this approach will give us a formal verification that the program t satisies the specification A. If one takes a proof assistant from the shelf, there is a danger that the theory underlying it does not match the theory one wants to formalize. Moreover, in a fundamental matter like tracing the development of mathematical theories down to their logical grass roots, one should understand in detail how proofs are represented and generated. As an additional benefits, one can experiment with new concepts and proof ideas, get a helpful display of the proof structure as a lambda-term (Curry- Howard correspondence), display the computational content of a proof again as a lambdaterm, and last not least machine check the correctness of proofs. As an experiment, the present appendix tries to guide the reader through the first steps of development of such a proof assistant, away from the user - mentality. 1

2

3 CHAPTER 1 Scheme The first decision to be taken is to select a programming language. We pick Scheme (see?), which is a particularly simple variant of Lisp (for LISt Processing); the latter was invented by?. A special feature of languages in the Lisp family is that procedures can be represented as data; this makes it easy to write programs that manipulate procedures Expressions; names and assignments We begin with simple examples; note the prefix notation. (+ 3 4) ==> 7 ( ) ==> 8 (* 13 (+ 2 4)) ==> 78 It is possible to assign values to names, and use them as abbreviations: (define size 2) ==> size size ==> 2 (* 5 size) ==> 10 (+ (* 5 size) (* size size)) ==> User defined procedures Apart from the primitive procedures like + and the user can define his own procedures (define (square x) (* x x)) or equivalently (define square (lambda (x) (* x x))) Then (square 3) ==> 9 (square (+ 2 5)) ==> 49 (square (square 3)) ==> 81 One can use square to define further procedures: (define (sum-of-squares x y) (+ (square x) (square y))) (sum-of-squares 3 4) ==> 25 3

4 4 1. SCHEME 1.3. Conditional expressions To express case distinctions like x if x > 0 abs(x) = 0 if x = 0 x if x < 0 one can use (define (abs x) (cond ((> x 0) x) ((= x 0) 0) ((< x 0) (- x)))) An alternative is (define (abs x) (cond ((< x 0) (- x)) (else x))) or (define (abs x) (if (< x 0) (- x) x)) Notive that cond and if are not procedures, but so-called special forms (they do not first evaluate all their arguments). The factorial function 1.4. Recursion 0! = 1, (n + 1)! = (n + 1) n!. can be implemented as (define (factorial n) (if (= 0 n) 1 (* n (factorial (- n 1))))) An iterative form of this definition is (define (factorial n) (fact-iter 1 1 n)) (define (fact-iter product counter max-count) (if (> counter max-count)

5 1.4. RECURSION 5 product (fact-iter (* counter product) (+ counter 1) max-count))) In product the result is accumulated. In an (unnested) tree recursion there can be many (unnested) calls to the function to be defined. An example is the Fibonacci function 0 if n = 0 Fib(n) := 1 if n = 1 Fib(n 1) + Fib(n 2) otherwise. A direct translation gives (define (fib n) (cond ((= 0 n) 0) ((= 1 n) 1) (else (+ (fib (- n 1)) (fib (- n 2)))))) Notice that the resulting computation is rather inefficient, since it involves many recomputations of values. Hence the following interative version is preferable. (define (fib n) (fib-iter 1 0 n)) (define (fib-iter a b count) (if (= 0 count) b (fib-iter (+ a b) a (- count 1)))) One can also have higher order procedures like (define (sum summand-fct next-fct a b) (if (> a b) 0 (+ (summand-fct a) (sum summand-fct next-fct (next-fct a) b)))) Notice that procedures are passed as arguments. We will also need do-loops. For example, we can compute the least n! larger than or equal to a given bound m by (define (facbound m) (do ((n 0 (+ 1 n)) (facn 1 (* (+ 1 n) facn))) ((<= m facn) facn)))

6 6 1. SCHEME 1.5. Pairs and lists Pairing is the main tool to build data in Lisp. To form a pair of two arguments we use the primitive procedure cons. From a pair one can read off its components by the primitive procedures car and cdr. The names car and cdr come from the original implementation of Lisp (on an IBM 704 machine). car is for contents of address register and cdr is for contents of decrement register. (define x (cons 1 2)) ==> x (car x) ==> 1 (cdr x) ==> 2 Note that a pair is a usual data object, that can be given a name and manipulated. (define x (cons 1 2)) ==> x (define y (cons 3 4)) ==> y (define z (cons x y)) ==> z (car (car z)) ==> 1 (car (cdr z)) ==> 3 One can use (caar z) and (cadr z) to abbreviate the final two expressions. Pairs are mainly used to form lists. Lists are represented by iterated pairing, where the cdr-field of the last pair remains empty. Notice that we need the empty list () as a new data object; the primitive procedure null? tests whether its argument is the empty list. For list processing the following procedures are helpful: list? list length append reverse list-ref member map An example for the usage of map is (define a (list )) ==> a

7 a ==> ( ) (map square a) ==> ( ) 1.7. EXERCISES Symbols and the necessity of quoting Suppose we want to have symbols as data objects, for instance (a b c d) ((a 1) (b 7) (c 3)) (* (+ 1 2) (+ x 7)) (define (factorial n) (if (= 0 n) 1 (* n (factorial (- n 1))))) To avoid searching for values of symbols we need quotation: (define a 1) ==> a (define b 2) ==> b (list a b) ==> (1 2) (list a b) ==> (a b) (list a b) ==> (a 2) (car (a b c)) ==> a (cdr (a b c)) ==> (b c) 1.7. Exercises Exercise (a) Compute in Scheme: ( ) (b) Define the following functions in Scheme: f(x, y) = x 2 y 2 1 if x > 0 s(x) = 0 if x = 0 1 if x < 0 (c) Define a function compose that takes two (unary, numerical) functions f and g and returns the new function f g. Exercise (Recursion, Lists). (a) Recursively define (pow x y) to compute x y for non-negative integer y, using multiplication and recursion. (b) Define a function maximum that maps a (non-empty) list of numbers to their maximum. (c) Define a function rev that takes a list and returns it with elements in reverse order.

8 8 1. SCHEME Exercise (Nested lists). Tree structures can naturally be represented in Scheme as nested lists. A B C D E F Figure 1. A labeled tree T of height 2, with associated nested list L T = (A (B (E) (F)) (C) (D (G))) For a labeled tree T inductively define its associated list L T height T as follows: G and its If T is a single leaf with label x (x not being a list), then L T := (x) and T := 0. If otherwise T is a node with label x and with children T 1,..., T n, then L T := (x L T1... L Tn ) and T := 1 + max 1 k n T k. Define a Scheme function that computes T, given a list L T. Exercise (Untyped λ-calculus). Let V be a set of variable symbols. λ-terms are syntactic expressions, inductively defined by these clauses: Variables x 1, x 2,... V are λ-terms. For λ-terms M and N, (M N) is a λ-term. (the application of M to N) For a λ-term M and a variable x, (λ x M) is a λ-term. (λ-abstraction of x: the function that maps x to M(x)) We associate λ-terms with Scheme expressions as follows: x = x (M N) = (M N) (λ x M) = (lambda (x) M) where M, N denote the expressions associated with M, N, respectively. As pool of variable symbols, use V := {a z, a1, a2,...}. (a) Define a Scheme function (is-lambda-term? M) that checks whether the expression M represents a valid λ-term M. (b) A variable occurrence of x in a term M is free, if it is not in the scope of a λ-abstraction of x. Define a function (free-vars M) that returns the list of variables that occur freely M. (c) Define a function (rename-var M x y) that returns the result of replacing free occurrences of x by y in the λ-term M (α-conversion).

9 1.7. EXERCISES 9 (d) Define a function (substitute M1 x M2) that replaces free occurrences of x in M1 by M2, while avoiding variable capture. Variable capture occurs when M2 is substituted into a context where a variable symbol that occurs freely in M2 is already bounded by λ-abstraction. Then the free occurrences accidentaly become bounded. To avoid this, the bounded variable should be renamed, using a fresh symbol. For example, when substituting x for y in the expression (lambda (x) (y x), the result should be (lambda (x1) (x x1)), not (lambda (x) (x x)). (e) To evaluate a λ-term M, one converts any instances of ((λ x M 1 )M 2 ) in M to M 1 [M 2 /x], where the latter is the result of substituting M 2 for x in M 1 (β-conversion). The resulting term is said to be in normal form. Define a function (eval-term M) that recursively replaces instances of type ((lambda (x) M1) M2) in M with (substitute M1 x M2). Remark. (i) Not every term in untyped lambda calculus has a normal form. Observe that, for example, (eval-term ((lambda (x) (x x) (lambda (x) (x x))))) does not terminate. By assigning types to λ- terms, one can restrict the term language to guarantee unique existence of normal forms (e.g. simply typed lambda calculus). (ii) Any recursive function can be represented within lambda calculus. Using the implementation of exercise 1.7.4, we can already perform arithmetic computations. Natural numbers are represented in λ-calculus as follows (Church numerals): n := λ f λ x (f(f... (f x))) }{{} n times The Scheme-routines below generate and translate Church numerals: (define (churchify n) (letrec ((nest-f (lambda (t n) (if (= 0 n) t (nest-f (list f t) (- n 1)))))) (list lambda (f) (list lambda (x) (nest-f x n))))) (define (unchurchify t) (eval (list (list t (lambda (x) (+ 1 x))) 0))) We can define and evaluate arithmetic expressions in λ-calculus: (define plus (lambda (m) (lambda (n) (lambda (f) (lambda (x) ((m f) ((n f) x))))))) (define times (lambda (m) (lambda (n) (lambda (f) (n (m f)))))) (define n (churchify 17)) (define m (churchify 42)) (define n+m (list (list plus n) m)) (unchurchify (eval-term n+m)) ;; => 59

10 10 1. SCHEME (define n*m (list (list times n) m)) (unchurchify (eval-term n*m)) ;; => 714 Exercise (Derivation checking). Derivations in implicational propositional logic correspond to (simply typed) λ-terms. Building on the previous exercise, we can implement simple proof checking for propositions with only and. Assume the following representation of implicational formulas in Scheme: Propositional variables p, q,... are written as quoted symbols p, q,.... Falsum is written as bot. Implications (A B) are represented as triples (-> A B), where A, B are the Scheme representations of the formulas A, B. For example, the formula (A B C) (A B) A C is represented by (-> (-> A (-> B C)) (-> (-> A B) (-> A C))). We next inductively associate derivations with λ-terms: [u: A] M N M = (lambda (u) M) A B A = (M N) B A B + u B where M and N are the terms associated with M and N, respectively. For assumptions, set [u: A] = u. For instance, the derivation u: A B C v : A w : A B v : A B C B C A C + v + w (A B) A C + u (A B C) (A B) A C is then associated with the term (lambda (u) (lambda (w) (lambda (v) ((u v) (w v))))) To determine the formula derived by such a term, one needs to know which formulas the assumption variables stand for. The types of the variables determine the type of the λ-term. For each derivation term we maintain a list context to keep track of the formulas (types) assigned to assumption variables: ((u (-> A (-> B C))) (v A) (w (-> A B))) This requires that variable names are used non-conflictingly in the derivation term. Instances of the same formula may be assigned the same assumption label, but no label can be used for different formulas simultaneously.

11 1.7. EXERCISES 11 A valid derivation is thus a pair of a λ-term and a context, satisfying the following conditions: (i) the context uniquely fixes the type of all assumption variables in the derivation term, and (ii) in cases of application (M N), M is of implication type and the antecedent has the type of N. (a) Define a Scheme function (is-formula? a) that checks whether a represents a formula in minimal implicational logic. (b) Define a function (is-valid-derivation? term context) that returns #t whenever term is a valid derivation, given context. (c) Define a function (infer-formula term context) that returns the formula derived by term, given context and a function (is-derivation-of? term context formula) that checks whether term is a derivation of formula, given context. Exercise (Proof automation for minimal implicational logic). Building on the two preceding exercises, define a Scheme function (prove goal-formula context) that returns a derivation term for goal-formula given context, if one exists. One can employ the following search strategy: (1) If goal-formula is part of context, return the corresponding assumption term. (2) If otherwise goal-formula is an implication, move the antecedent into the context (using abstraction) and attempt to prove the consequent. (3) Else try applying formulas from the context to each other and add the resulting new inferences to context. If new formulas can be added, recursively call prove with extended context, otherwise return #f the formula was not derivable.

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

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

### Chapter 1. Fundamentals of Higher Order Programming

Chapter 1 Fundamentals of Higher Order Programming 1 The Elements of Programming Any powerful language features: so does Scheme primitive data procedures combinations abstraction We will see that Scheme

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

### Streams, Delayed Evaluation and a Normal Order Interpreter. CS 550 Programming Languages Jeremy Johnson

Streams, Delayed Evaluation and a Normal Order Interpreter CS 550 Programming Languages Jeremy Johnson 1 Theme This lecture discusses the stream model of computation and an efficient method of implementation

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

### Functional programming with Common Lisp

Functional programming with Common Lisp Dr. C. Constantinides Department of Computer Science and Software Engineering Concordia University Montreal, Canada August 11, 2016 1 / 81 Expressions and functions

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

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

### Programming Languages

Programming Languages Lambda Calculus and Scheme CSCI-GA.2110-003 Fall 2011 λ-calculus invented by Alonzo Church in 1932 as a model of computation basis for functional languages (e.g., Lisp, Scheme, ML,

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

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

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

### An introduction to Scheme

An introduction to Scheme Introduction A powerful programming language is more than just a means for instructing a computer to perform tasks. The language also serves as a framework within which we organize

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

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

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

### Tail Recursion. ;; a recursive program for factorial (define fact (lambda (m) ;; m is non-negative (if (= m 0) 1 (* m (fact (- m 1))))))

Tail Recursion 1 Tail Recursion In place of loops, in a functional language one employs recursive definitions of functions. It is often easy to write such definitions, given a problem statement. Unfortunately,

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

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

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

### Recursion. Tjark Weber. Functional Programming 1. Based on notes by Sven-Olof Nyström. Tjark Weber (UU) Recursion 1 / 37

Tjark Weber Functional Programming 1 Based on notes by Sven-Olof Nyström Tjark Weber (UU) Recursion 1 / 37 Background FP I / Advanced FP FP I / Advanced FP This course (Functional Programming I) (5 hp,

### Typed Racket: Racket with Static Types

Typed Racket: Racket with Static Types Version 5.0.2 Sam Tobin-Hochstadt November 6, 2010 Typed Racket is a family of languages, each of which enforce that programs written in the language obey a type

### CS450 - Structure of Higher Level Languages

Spring 2018 Streams February 24, 2018 Introduction Streams are abstract sequences. They are potentially infinite we will see that their most interesting and powerful uses come in handling infinite sequences.

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

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

### 6.184 Lecture 4. Interpretation. Tweaked by Ben Vandiver Compiled by Mike Phillips Original material by Eric Grimson

6.184 Lecture 4 Interpretation Tweaked by Ben Vandiver Compiled by Mike Phillips Original material by Eric Grimson 1 Interpretation Parts of an interpreter Arithmetic calculator

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

### An Introduction to Scheme

An Introduction to Scheme Stéphane Ducasse stephane.ducasse@inria.fr http://stephane.ducasse.free.fr/ Stéphane Ducasse 1 Scheme Minimal Statically scoped Functional Imperative Stack manipulation Specification

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

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

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

### Lambda Calculus and Lambda notation in Lisp II. Based on Prof. Gotshalks notes on Lambda Calculus and Chapter 9 in Wilensky.

λ Calculus Basis Lambda Calculus and Lambda notation in Lisp II Based on Prof. Gotshalks notes on Lambda Calculus and Chapter 9 in Wilensky Mathematical theory for anonymous functions» functions that have

### CS61A Discussion Notes: Week 11: The Metacircular Evaluator By Greg Krimer, with slight modifications by Phoebus Chen (using notes from Todd Segal)

CS61A Discussion Notes: Week 11: The Metacircular Evaluator By Greg Krimer, with slight modifications by Phoebus Chen (using notes from Todd Segal) What is the Metacircular Evaluator? It is the best part

### Introduction to Functional Programming

Introduction to Functional Programming Xiao Jia xjia@cs.sjtu.edu.cn Summer 2013 Scheme Appeared in 1975 Designed by Guy L. Steele Gerald Jay Sussman Influenced by Lisp, ALGOL Influenced Common Lisp, Haskell,

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

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

### The Typed Racket Guide

The Typed Racket Guide Version 5.3.6 Sam Tobin-Hochstadt and Vincent St-Amour August 9, 2013 Typed Racket is a family of languages, each of which enforce

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

### Lambda Calculus see notes on Lambda Calculus

Lambda Calculus see notes on Lambda Calculus Shakil M. Khan adapted from Gunnar Gotshalks recap so far: Lisp data structures basic Lisp programming bound/free variables, scope of variables Lisp symbols,

### Pure Lambda Calculus. Lecture 17

Pure Lambda Calculus Lecture 17 Lambda Calculus Lambda Calculus (λ-calculus) is a functional notation introduced by Alonzo Church in the early 1930s to formalize the notion of computability. Pure λ-calculus

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

### Scheme Quick Reference

Scheme Quick Reference COSC 18 Winter 2003 February 10, 2003 1 Introduction This document is a quick reference guide to common features of the Scheme language. It is by no means intended to be a complete

### Documentation for LISP in BASIC

Documentation for LISP in BASIC The software and the documentation are both Copyright 2008 Arthur Nunes-Harwitt LISP in BASIC is a LISP interpreter for a Scheme-like dialect of LISP, which happens to have

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

### Recursion & Iteration

Recursion & Iteration York University Department of Computer Science and Engineering 1 Overview Recursion Examples Iteration Examples Iteration vs. Recursion Example [ref.: Chap 5,6 Wilensky] 2 Recursion

### CS 314 Principles of Programming Languages

CS 314 Principles of Programming Languages Lecture 17: Functional Programming Zheng (Eddy Zhang Rutgers University April 4, 2018 Class Information Homework 6 will be posted later today. All test cases

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

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

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

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

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

### SOFTWARE ARCHITECTURE 6. LISP

1 SOFTWARE ARCHITECTURE 6. LISP Tatsuya Hagino hagino@sfc.keio.ac.jp slides URL https://vu5.sfc.keio.ac.jp/sa/ 2 Compiler vs Interpreter Compiler Translate programs into machine languages Compilers are

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

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

### CMPSCI 250: Introduction to Computation. Lecture #14: Induction and Recursion (Still More Induction) David Mix Barrington 14 March 2013

CMPSCI 250: Introduction to Computation Lecture #14: Induction and Recursion (Still More Induction) David Mix Barrington 14 March 2013 Induction and Recursion Three Rules for Recursive Algorithms Proving

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

### Introduction. chapter Functions

chapter 1 Introduction In this chapter we set the stage for the rest of the book. We start by reviewing the notion of a function, then introduce the concept of functional programming, summarise the main

### 6.001 Notes: Section 4.1

6.001 Notes: Section 4.1 Slide 4.1.1 In this lecture, we are going to take a careful look at the kinds of procedures we can build. We will first go back to look very carefully at the substitution model,

### Comp 311: Sample Midterm Examination

Comp 311: Sample Midterm Examination October 29, 2007 Name: Id #: Instructions 1. The examination is closed book. If you forget the name for a Scheme operation, make up a name for it and write a brief

### Discussion 12 The MCE (solutions)

Discussion 12 The MCE (solutions) ;;;;METACIRCULAR EVALUATOR FROM CHAPTER 4 (SECTIONS 4.1.1-4.1.4) of ;;;; STRUCTURE AND INTERPRETATION OF COMPUTER PROGRAMS ;;;from section 4.1.4 -- must precede def of

### Lambda Calculus LC-1

Lambda Calculus LC-1 λ- Calculus History-1 Developed by Alonzo Church during 1930 s-40 s One fundamental goal was to describe what can be computed. Full definition of λ-calculus is equivalent in power

### Modern Programming Languages. Lecture LISP Programming Language An Introduction

Modern Programming Languages Lecture 18-21 LISP Programming Language An Introduction 72 Functional Programming Paradigm and LISP Functional programming is a style of programming that emphasizes the evaluation

### 6.001 Notes: Section 8.1

6.001 Notes: Section 8.1 Slide 8.1.1 In this lecture we are going to introduce a new data type, specifically to deal with symbols. This may sound a bit odd, but if you step back, you may realize that everything

### Scheme Quick Reference

Scheme Quick Reference COSC 18 Fall 2003 This document is a quick reference guide to common features of the Scheme language. It is not intended to be a complete language reference, but it gives terse summaries

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

### Recursion. Lars-Henrik Eriksson. Functional Programming 1. Based on a presentation by Tjark Weber and notes by Sven-Olof Nyström

Lars-Henrik Eriksson Functional Programming 1 Based on a presentation by Tjark Weber and notes by Sven-Olof Nyström Tjark Weber (UU) Recursion 1 / 41 Comparison: Imperative/Functional Programming Comparison:

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

### 15 Unification and Embedded Languages in Lisp

15 Unification and Embedded Languages in Lisp Chapter Objectives Chapter Contents Pattern matching in Lisp: Database examples Full unification as required for Predicate Calculus problem solving Needed

### Lecture #24: Programming Languages and Programs

Lecture #24: Programming Languages and Programs A programming language is a notation for describing computations or processes. These range from low-level notations, such as machine language or simple hardware

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

### Programming Language Pragmatics

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

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

### Normal Order (Lazy) Evaluation SICP. Applicative Order vs. Normal (Lazy) Order. Applicative vs. Normal? How can we implement lazy evaluation?

Normal Order (Lazy) Evaluation Alternative models for computation: Normal (Lazy) Order Evaluation Memoization Streams Applicative Order: evaluate all arguments, then apply operator Normal Order: pass unevaluated

### Type Systems COMP 311 Rice University Houston, Texas

Rice University Houston, Texas 1 Type Systems for Programming Language were invented by mathematicians before electronic computers were invented. What is a type? A meaningful subset of the set of the domain

### Recursion and Structural Induction

Recursion and Structural Induction Mukulika Ghosh Fall 2018 Based on slides by Dr. Hyunyoung Lee Recursively Defined Functions Recursively Defined Functions Suppose we have a function with the set of non-negative

### Scheme in Scheme: The Metacircular Evaluator Eval and Apply

Scheme in Scheme: The Metacircular Evaluator Eval and Apply CS21b: Structure and Interpretation of Computer Programs Brandeis University Spring Term, 2015 The metacircular evaluator is A rendition of Scheme,

### Below are example solutions for each of the questions. These are not the only possible answers, but they are the most common ones.

6.001, Fall Semester, 2002 Quiz II Sample solutions 1 MASSACHVSETTS INSTITVTE OF TECHNOLOGY Department of Electrical Engineering and Computer Science 6.001 Structure and Interpretation of Computer Programs

### Recursively Defined Functions

Section 5.3 Recursively Defined Functions Definition: A recursive or inductive definition of a function consists of two steps. BASIS STEP: Specify the value of the function at zero. RECURSIVE STEP: Give

### Lists. Michael P. Fourman. February 2, 2010

Lists Michael P. Fourman February 2, 2010 1 Introduction The list is a fundamental datatype in most functional languages. ML is no exception; list is a built-in ML type constructor. However, to introduce

### Overview. CS301 Session 3. Problem set 1. Thinking recursively

Overview CS301 Session 3 Review of problem set 1 S-expressions Recursive list processing Applicative programming A look forward: local variables 1 2 Problem set 1 Don't use begin unless you need a side

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

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

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

### CS4215 Programming Language Implementation. Martin Henz

CS4215 Programming Language Implementation Martin Henz Thursday 26 January, 2012 2 Chapter 4 The Language simpl In this chapter, we are exting the language epl in order to provide a more powerful programming

### Lambda Calculus. Gunnar Gotshalks LC-1

Lambda Calculus LC-1 l- Calculus History Developed by Alonzo Church during 1930 s-40 s One fundamental goal was to describe what can be computed. Full definition of l-calculus is equivalent in power to

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

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

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