# 6.001: Structure and Interpretation of Computer Programs

Size: px
Start display at page:

Transcription

1 6.001: Structure and Interpretation of Computer Programs Symbols Quotation Relevant details of the reader Example of using symbols Alists Differentiation

2 Data Types in Lisp/Scheme Conventional Numbers (integer, real, rational, complex) Interesting property in real Scheme: exactness Booleans: #t, #f Characters and strings: #\a, Hello World! Vectors: #(0 hi 3.7) Lisp-specific Procedures: value of +, result of evaluating ( (x) x) Pairs and Lists: (3. 7), ( ) Symbols: pi, +, MyGreatGrandMotherSue

3 Symbols So far, we ve seen them as the names of variables But, in Lisp, all data types are first class Therefore, we should be able to Pass symbols as arguments to procedures Return them as values of procedures Associate them as values of variables Store them in data structures E.g., (apple orange banana) apple orange banana

4 How do we refer to Symbols? Substitution Model s rule of evaluation: Value of a symbol is the value it is associated with in the environment We associate symbols with values using the special form define (define pi ) but that doesn t help us get at the symbol itself

5 Referring to Symbols Say your favorite color Say your favorite color In the first case, we want the meaning associated with the expression, e.g., red In the second, we want the expression itself, e.g., your favorite color We use quotation to distinguish our intended meaning

6 New Special Form: quote Need a way of telling interpreter: I want the following object as whatever it is, not as an expression to be evaluated (quote alpha) ;Value: alpha (+ pi pi) ;Value: (define pi ) ;Value: "pi --> " pi ;Value: (quote pi) ;Value: pi (+ pi (quote pi)) ;The object pi, passed as the first argument to integer->flonum, is not the correct type. (define fav (quote pi)) fav ;Value: pi

7 Review: data abstraction A data abstraction consists of: constructors selectors operations contract (define make-point (lambda (x y) (list x y))) (define x-coor (lambda (pt) (car pt))) (define on-y-axis? (lambda (pt) (= (x-coor pt) 0))) (x-coor (make-point <x> <y>)) = <x>

8 Symbol: a primitive type constructors: None since really a primitive, not an object with parts Only way to make one is to type it (or via string->symbol from character strings, but shhhh ) selectors None (except symbol->string) R5RS shows the full riches of Scheme operations: symbol? ; type: anytype -> boolean (symbol? (quote alpha)) ==> #t eq? ; discuss in a minute

9 What s the difference between symbols and strings? Symbol Evaluates to the value associated with it by define Every time you type a particular symbol, you get the exact same one! Guaranteed. Called interning E.g., (list (quote pi) (quote pi)) String Evaluates to itself Every time you type a particular string, it s up to the implementation whether you get the same one or different ones. E.g., (list pi pi ) pi or pi pi pi

10 The operation eq? tests for the same object a primitive procedure returns #t if its two arguments are the same object very fast (eq? (quote eps) (quote eps)) ==> #t (eq? (quote delta) (quote eps)) ==> #f For those who are interested: ; eq?: EQtype, EQtype ==> boolean ; EQtype = any type except number or string One should therefore use = for equality of numbers, not eq?

11 Making list structure with symbols ((red 700) (orange 600) (yellow 575) (green 550) (cyan 510) (blue 470) (violet 400)) red 700 orange 600 violet 400 (list (list (quote red) 700) (list (quote orange) 600) (list (quote violet) 400))

12 More Syntactic Sugar To the reader, pi is exactly the same as if you had typed (quote pi) Remember REPL User types pi pi 'pi ;Value: pi read print (quote pi) eval pi

13 More Syntactic Sugar To the reader, pi is exactly the same as if you had typed (quote pi) Remember REPL User types 'pi ;Value: pi '17 ;Value: 17 '"hi there" ;Value: "hi there" read print (quote 17) eval 17

14 More Syntactic Sugar To the reader, pi is exactly the same as if you had typed (quote pi) Remember REPL 'pi ;Value: pi '17 ;Value: 17 '"hi there" ;Value: "hi there" User types (+ 3 4) read (quote (+ 3 4)) eval (+ 3 4) print (+ 3 4) '(+ 3 4) ;Value: (+ 3 4)

15 More Syntactic Sugar To the reader, pi is exactly the same as if you had typed (quote pi) Remember REPL User types pi (quote pi) 'pi ;Value: pi '17 ;Value: 17 '"hi there" ;Value: "hi there" '(+ 3 4) ;Value: (+ 3 4) read (quote eval (quote pi)) print (quote pi) ''pi ;Value: (quote pi) But in Dr. Scheme, 'pi

16 But wait Clues about guts of Scheme (pair? (quote (+ 2 3))) ;Value: #t (pair? '(+ 2 3)) ;Value: #t (car '(+ 2 3)) ;Value: + (cadr '(+ 2 3)) ;Value: 2 (null? (cdddr '(+ 2 3))) ;Value: #t Now we know that expressions are represented by lists!

17 Your turn: what does evaluating these print out? (define x 20) (+ x 3) ==> '(+ x 3) ==> (list (quote +) x '3) ==> (list '+ x 3) ==> (list + x 3) ==> 23 (+ x 3) (+ 20 3) (+ 20 3) ([procedure # ] 20 3)

18 ' The Grimson Rule of Thumb for Quote '((quote fred) (quote quote) (+ 3 5))) (quote ((quote fred) (quote quote) (+ 3 5))))??? What's the value of the quoted expression? WHATEVER IS UNDER YOUR THUMB! ('fred 'quote (+ 3 5)))

19 Revisit making list structure with symbols red 700 violet 400 orange 600 (list (list (quote red) 700) (list (quote orange) 600) (list (quote violet) 400)) (list (list red 700) (list orange 600) (list violet 400)) ((red 700) (orange 600) (yellow 575) (green 550) (cyan 510) (blue 470) (violet 400)) Because the reader knows how to turn parenthesized (for lists) and dotted (for pairs) expressions into list structure!

20 Aside: What all does the reader know? Recognizes and creates Various kinds of numbers 312 ==> integer 3.12e17 ==> real, etc. Strings enclosed by Booleans #t and #f Symbols ==> (quote ) ( ) ==> pairs (and lists, which are made of pairs) and a few other obscure things

21 Traditional LISP structure: association list A list where each element is a list of the key and value. Represent the table x: 15 y: 20 as the alist: ((x 15) (y 20)) x 15 y 20

22 Alist operation: find-assoc (define (find-assoc key alist) (cond ((null? alist) #f) ((equal? key (caar alist)) (cadar alist)) (else (find-assoc key (cdr alist))))) (define a1 '((x 15) (y 20))) (find-assoc 'y a1) ==> 20 x 15 y 20

23 An aside on testing equality = Eq? Equal? tests equality of numbers Tests equality of symbols Tests equality of symbols, numbers or lists of symbols and/or numbers that print the same

24 Alist operation: add-assoc (define (add-assoc key val alist) (cons (list key val) alist)) (define a2 (add-assoc 'y 10 a1)) a2 ==> ((y 10) (x 15) (y 20)) (find-assoc 'y a2) ==> 10 We say that the new binding for y shadows the previous one

25 Alists are not an abstract data type Missing a constructor: Used quote or list to construct (define a1 '((x 15) (y 20))) There is no abstraction barrier: the implementation is exposed. User may operate on alists using standard list operations. (filter (lambda (a) (< (cadr a) 16)) a1)) ==> ((x 15))

26 Why do we care that Alists are not an ADT? Modularity is essential for software engineering Build a program by sticking modules together Can change one module without affecting the rest Alists have poor modularity Programs may use list ops like filter and map on alists These ops will fail if the implementation of alists change Must change whole program if you want a different table To achieve modularity, hide information Hide the fact that the table is implemented as a list Do not allow rest of program to use list operations ADT techniques exist in order to do this

27 Symbolic differentiation (deriv <expr> <with-respect-to-var>) ==> <new-expr> Algebraic expression Representation x + 3 (+ x 3) x x 5y (* 5 y) x + y + 3 (+ x (+ y 3)) (deriv '(+ x 3) 'x) ==> 1 (deriv '(+ (* x y) 4) 'x) ==> y (deriv '(* x x) 'x) ==> (+ x x)

28 Building a system for differentiation Example of: Lists of lists How to use the symbol type Symbolic manipulation 1. how to get started 2. a direct implementation 3. a better implementation

29 1. How to get started Analyze the problem precisely deriv constant dx = 0 deriv variable dx = 1 if variable is the same as x = 0 otherwise deriv (e1+e2) dx deriv (e1*e2) dx = deriv e1 dx + deriv e2 dx = e1 * (deriv e2 dx) + e2 * (deriv e1 dx) Observe: e1 and e2 might be complex subexpressions derivative of (e1+e2) formed from deriv e1 and deriv e2 a tree problem

30 Type of the data will guide implementation legal expressions x (+ x y) 2 (* 2 x) (+ (* x y) 3) illegal expressions * (3 5 +) (+ x y z) () (3) (* x) ; Expr = SimpleExpr CompoundExpr ; SimpleExpr = number symbol ; CompoundExpr = a list of three elements where the first element is either + or * ; = pair< (+ *), pair<expr, pair<expr,null> >>

31 2. A direct implementation Overall plan: one branch for each subpart of the type (define deriv (lambda (expr var) (if (simple-expr? expr) <handle simple expression> <handle compound expression> ))) To implement simple-expr? look at the type CompoundExpr is a pair nothing inside SimpleExpr is a pair therefore (define simple-expr? (lambda (e) (not (pair? e))))

32 Simple expressions One branch for each subpart of the type (define deriv (lambda (expr var) (if (simple-expr? expr) ))) (if (number? expr) <handle number> <handle symbol> ) <handle compound expression> 0 (if (eq? expr var) 1 0) Implement each branch by looking at the math

33 Compound expressions One branch for each subpart of the type (define deriv (lambda (expr var) (if (simple-expr? expr) (if (number? expr) 0 (if (eq? expr var) 1 0)) (if (eq? (car expr) '+) <handle add expression> <handle product expression> ) )))

34 Sum expressions To implement the sum branch, look at the math (define deriv (lambda (expr var) (if (simple-expr? expr) (if (number? expr) 0 (if (eq? expr var) 1 0)) (if (eq? (car expr) '+) (list '+ (deriv (cadr expr) var) (deriv (caddr expr) var)) <handle product expression> ) ))) (deriv '(+ x y) 'x) ==> (+ 1 0) (a list!)

35 The direct implementation works, but... Programs always change after initial design Hard to read Hard to extend safely to new operators or simple exprs Can't change representation of expressions Source of the problems: nested if expressions explicit access to and construction of lists few useful names within the function to guide reader

36 3. A better implementation 1. Use cond instead of nested if expressions 2. Use data abstraction To use cond: write a predicate that collects all tests to get to a branch: (define sum-expr? (lambda (e) (and (pair? e) (eq? (car e) '+)))) ; type: Expr -> boolean do this for every branch: (define variable? (lambda (e) (and (not (pair? e)) (symbol? e))))

37 Use data abstractions To eliminate dependence on the representation: (define make-sum (lambda (e1 e2) (list '+ e1 e2)) (define addend (lambda (sum) (cadr sum))) (define augend (lambda (sum) (caddr sum)))

38 A better implementation (define deriv (lambda (expr var) (cond ((number? expr) 0) ((variable? expr) (if (eq? expr var) 1 0)) ((sum-expr? expr) (make-sum (deriv (addend expr) var) (deriv (augend expr) var))) ((product-expr? expr) <handle product expression>) (else (error "unknown expression type" expr)) ))

39 Isolating changes to improve performance (deriv '(+ x y) 'x) ==> (+ 1 0) (a list!) (define make-sum (lambda (e1 e2) (cond ((number? e1) (if (number? e2) (+ e1 e2) (list '+ e1 e2))) ((number? e2) (list '+ e2 e1)) (else (list '+ e1 e2))))) (deriv '(+ x y) 'x) ==> 1

40 Modularity makes changes easier But conventional mathematics doesn t use prefix notation like this: (+ 2 x) or (* (+ 3 x) (+ x y)) Could we change our program somehow to use more algebraic expressions, still fully parenthesized, like: (2 + x) or ((3 + x) * (x + y)) What do we need to change?

41 Just change data abstraction Constructors (define (make-sum e1 e2) (list e1 '+ e2)) Accessors (define (augend expr) (caddr expr)) Predicates (define (sum-expr? expr) (and (pair? expr) (eq? '+ (cadr expr))))

42 Separating simplification from differentiation Exploit Modularity: Rather than changing the code to handle simplification of expressions, write a separate simplifier (define (simplify expr) (cond ((or (number? expr) (variable? expr)) expr) ((sum-expr? expr) (simplify-sum (simplify (addend expr)) (simplify (augend expr)))) ((product-expr? expr) (simplify-product (simplify (multiplier expr)) (simplify (multiplicand expr)))) (else (error "unknown expr type" expr))))

43 Simplifying sums (define (simplify-sum add aug) (cond ((and (number? add) (number? aug)) ;; both terms are numbers: add them (+ add aug)) ((or (number? add) (number? aug)) ;; one term only is number (cond ((and (number? add) (zero? add)) aug) ((and (number? aug) (zero? aug)) add) (else (make-sum add aug)))) ((eq? add aug) ;; adding same term twice (make-product 2 add)) (+ 2 3) 5 (+ 0 x) x (+ x 0) x (+ 2 x) (+ 2 x) (+ x x) (* 2 x)

44 More special cases in simplification (define (simplify-sum add aug) (cond ((product-expr? aug) ;; check for special case of (+ x (* 3 x)) ;; i.e., adding something to a multiple of itself (let ((mulr (simplify (multiplier aug))) (muld (simplify (multiplicand aug)))) (if (and (number? mulr) (eq? add muld)) (make-product (+ 1 mulr) add) ;; not special case: lose (make-sum add aug)))) (else (make-sum add aug)))) (+ x (* 3 x)) (* 4 x)

45 Special cases in simplifying products (define (simplify-product f1 f2) (cond ((and (number? f1) (number? f2)) (* f1 f2)) ((number? f1) (cond ((zero? f1) 0) ((= f1 1) f2) (else (make-product f1 f2)))) ((number? f2) (cond ((zero? f2) 0) ((= f2 1) f1) (* 3 5) 15 (else (make-product f2 f1)))) (else (make-product f1 f2)))) (* 0 (+ x 1)) 0 (* 1 (+ x 1)) (+ x 1) (* (+ 3 x) 2) (* 2 (+ 3 x))

46 Simplified derivative looks better (deriv '(+ x 3) 'x) ;Value: (+ 1 0) (deriv '(+ x (* x y)) 'x) ;Value: (+ 1 (+ (* x 0) (* 1 y))) (simplify (deriv '(+ x 3) 'x)) ;Value: 1 (simplify (deriv '(+ x (* x y)) 'x)) ;Value: (+ 1 y) But, which is simpler? a*(b+c) or a*b + a*c Depends on context

47 Recap Symbols Are first class objects Allow us to represent names Quotation (and the reader s syntactic sugar for ') Let us evaluate (quote ) to get as the value I.e., prevents one evaluation Not really, but informally, has that effect. Lisp expressions are represented as lists Encourages writing programs that manipulate programs Much more, later Symbolic differentiation (introduction)

### Data abstraction, revisited

Data abstraction, revisited Design tradeoffs: Speed vs robustness modularity ease of maintenance Table abstract data type: 3 versions No implementation of an ADT is necessarily "best" Abstract data types

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

### Building a system for symbolic differentiation

Computer Science 21b Structure and Interpretation of Computer Programs Building a system for symbolic differentiation Selectors, constructors and predicates: (constant? e) Is e a constant? (variable? e)

### Using Symbols in Expressions (1) evaluate sub-expressions... Number. ( ) machine code to add

Using Symbols in Expressions (1) (define z y) z Symbol y z ==> y prints as (+ x 3) evaluate sub-expressions... PrimProc Number Number ( ) machine code to add 23 3 Number 26 apply... ==> 26 prints as 1

Administrivia Lists, higher order procedures, and symbols 6.037 - Structure and Interpretation of Computer Programs Mike Phillips (mpp) Massachusetts Institute of Technology Project 0 was due today Reminder:

### Building a system for symbolic differentiation

Computer Science 21b Structure and Interpretation of Computer Programs Building a system for symbolic differentiation Selectors, constructors and predicates: (constant? e) Is e a constant? (variable? e)

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

### Syntactic Sugar: Using the Metacircular Evaluator to Implement the Language You Want

Computer Science 21b (Spring Term, 2017) Structure and Interpretation of Computer Programs Syntactic Sugar: Using the Metacircular Evaluator to Implement the Language You Want Here is one of the big ideas

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

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

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

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

### 6.037 Lecture 4. Interpretation. What is an interpreter? Why do we need an interpreter? Stages of an interpreter. Role of each part of the interpreter

6.037 Lecture 4 Interpretation Interpretation Parts of an interpreter Meta-circular Evaluator (Scheme-in-scheme!) A slight variation: dynamic scoping Original material by Eric Grimson Tweaked by Zev Benjamin,

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

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

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

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

### Why do we need an interpreter? SICP Interpretation part 1. Role of each part of the interpreter. 1. Arithmetic calculator.

.00 SICP Interpretation part Parts of an interpreter Arithmetic calculator Names Conditionals and if Store procedures in the environment Environment as explicit parameter Defining new procedures Why do

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

### CSc 520 Principles of Programming Languages

CSc 520 Principles of Programming Languages 9: Scheme Metacircular Interpretation Christian Collberg collberg@cs.arizona.edu Department of Computer Science University of Arizona Copyright c 2005 Christian

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

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

### Procedural abstraction SICP Data abstractions. The universe of procedures forsqrt. Procedural abstraction example: sqrt

Data abstractions Abstractions and their variations Basic data abstractions Why data abstractions are useful Procedural abstraction Process of procedural abstraction Define formal parameters, capture process

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

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

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

### 6.001 Notes: Section 15.1

6.001 Notes: Section 15.1 Slide 15.1.1 Our goal over the next few lectures is to build an interpreter, which in a very basic sense is the ultimate in programming, since doing so will allow us to define

### Intro. Scheme Basics. scm> 5 5. scm>

Intro Let s take some time to talk about LISP. It stands for LISt Processing a way of coding using only lists! It sounds pretty radical, and it is. There are lots of cool things to know about LISP; if

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

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

### Scheme: Data. CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Monday, April 3, Glenn G.

Scheme: Data CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Monday, April 3, 2017 Glenn G. Chappell Department of Computer Science University of Alaska Fairbanks ggchappell@alaska.edu

### C311 Lab #3 Representation Independence: Representation Independent Interpreters

C311 Lab #3 Representation Independence: Representation Independent Interpreters Will Byrd webyrd@indiana.edu February 5, 2005 (based on Professor Friedman s lecture on January 29, 2004) 1 Introduction

### Building up a language SICP Variations on a Scheme. Meval. The Core Evaluator. Eval. Apply. 2. syntax procedures. 1.

6.001 SICP Variations on a Scheme Scheme Evaluator A Grand Tour Techniques for language design: Interpretation: eval/appl Semantics vs. snta Sntactic transformations Building up a language... 3. 1. eval/appl

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

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

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

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

### Scheme: Expressions & Procedures

Scheme: Expressions & Procedures CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Friday, March 31, 2017 Glenn G. Chappell Department of Computer Science University

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

### Evaluating Scheme Expressions

Evaluating Scheme Expressions How Scheme evaluates the expressions? (procedure arg 1... arg n ) Find the value of procedure Find the value of arg 1 Find the value of arg n Apply the value of procedure

### From Syntactic Sugar to the Syntactic Meth Lab:

From Syntactic Sugar to the Syntactic Meth Lab: Using Macros to Cook the Language You Want a V E N E TRUT H Brandeis S PA R T U N T O I T S I N N E R M OS T COMPUTER SCIENCE 21B: Structure and Interpretation

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

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

### ALISP interpreter in Awk

ALISP interpreter in Awk Roger Rohrbach 1592 Union St., #94 San Francisco, CA 94123 January 3, 1989 ABSTRACT This note describes a simple interpreter for the LISP programming language, written in awk.

### Principles of Programming Languages

Principles of Programming Languages www.cs.bgu.ac.il/~ppl172 Lesson 6 - Defining a Programming Language Bottom Up Collaboration and Management - Elements of Programming Dana Fisman 1 What we accomplished

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

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

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

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

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

### CS 360 Programming Languages Interpreters

CS 360 Programming Languages Interpreters Implementing PLs Most of the course is learning fundamental concepts for using and understanding PLs. Syntax vs. semantics vs. idioms. Powerful constructs like

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

1 of 5 5/11/2006 12:10 AM CS 61A Spring 2006 Midterm 2 solutions 1. Box and pointer. Note: Please draw actual boxes, as in the book and the lectures, not XX and X/ as in these ASCII-art solutions. Also,

### 6.037 Lecture 7B. Scheme Variants Normal Order Lazy Evaluation Streams

6.037 Lecture 7B Scheme Variants Normal Order Lazy Evaluation Streams Edited by Mike Phillips & Ben Vandiver Original Material by Eric Grimson & Duane Boning Further Variations on a Scheme Beyond Scheme

### University of Massachusetts Lowell

University of Massachusetts Lowell 91.301: Organization of Programming Languages Fall 2002 Quiz 1 Solutions to Sample Problems 2 91.301 Problem 1 What will Scheme print in response to the following statements?

### Fall Semester, The Metacircular Evaluator. Today we shift perspective from that of a user of computer langugaes to that of a designer of

1 MASSACHVSETTS INSTITVTE OF TECHNOLOGY Department of Electrical Engineering and Computer Science 6.001 Structure and Interpretation of Computer Programs Fall Semester, 1996 Lecture Notes { October 31,

### Computer Science 21b (Spring Term, 2015) Structure and Interpretation of Computer Programs. Lexical addressing

Computer Science 21b (Spring Term, 2015) Structure and Interpretation of Computer Programs Lexical addressing The difference between a interpreter and a compiler is really two points on a spectrum of possible

### 6.001 Notes: Section 6.1

6.001 Notes: Section 6.1 Slide 6.1.1 When we first starting talking about Scheme expressions, you may recall we said that (almost) every Scheme expression had three components, a syntax (legal ways of

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

### CS 480. Lisp J. Kosecka George Mason University. Lisp Slides

CS 480 Lisp J. Kosecka George Mason University Lisp Slides Symbolic Programming Symbols: +, -, 1, 2 etc. Symbolic expressions: (+ 1 2), (+ (* 3 4) 2) Symbolic programs are programs that manipulate symbolic

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

### cs61amt2_4 CS 61A Midterm #2 ver March 2, 1998 Exam version: A Your name login: cs61a- Discussion section number TA's name

CS 61A Midterm #2 ver1.03 -- March 2, 1998 Exam version: A Your name login: cs61a- Discussion section number TA's name Look at the edge of your seat. Write your ROOM, seat row and number. Your row number

### Vectors in Scheme. Data Structures in Scheme

Data Structures in Scheme Vectors in Scheme In Scheme, lists and S-expressions are basic. Arrays can be simulated using lists, but access to elements deep in the list can be slow (since a list is a linked

### Symbolic Programming. Dr. Zoran Duric () Symbolic Programming 1/ 89 August 28, / 89

Symbolic Programming Symbols: +, -, 1, 2 etc. Symbolic expressions: (+ 1 2), (+ (* 3 4) 2) Symbolic programs are programs that manipulate symbolic expressions. Symbolic manipulation: you do it all the

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

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

### CSE 413 Languages & Implementation. Hal Perkins Winter 2019 Structs, Implementing Languages (credits: Dan Grossman, CSE 341)

CSE 413 Languages & Implementation Hal Perkins Winter 2019 Structs, Implementing Languages (credits: Dan Grossman, CSE 341) 1 Goals Representing programs as data Racket structs as a better way to represent

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

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

### 6.034 Artificial Intelligence February 9, 2007 Recitation # 1. (b) Draw the tree structure corresponding to the following list.

6.034 Artificial Intelligence February 9, 2007 Recitation # 1 1 Lists and Trees (a) You are given two lists: (define x (list 1 2 3)) (define y (list 4 5 6)) What would the following evaluate to: (append

### Turtles All The Way Down

Turtles All The Way Down Bertrand Russell had just finished giving a public lecture on the nature of the universe. An old woman said Prof. Russell, it is well known that the earth rests on the back of

### CSc 520 Principles of Programming Languages

CSc 520 Principles of Programming Languages 3: Scheme Introduction Christian Collberg collberg@cs.arizona.edu Department of Computer Science University of Arizona Copyright c 2005 Christian Collberg [1]

### regsim.scm ~/umb/cs450/ch5.base/ 1 11/11/13

1 File: regsim.scm Register machine simulator from section 5.2 of STRUCTURE AND INTERPRETATION OF COMPUTER PROGRAMS This file can be loaded into Scheme as a whole. Then you can define and simulate machines

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

### CS61A Midterm 2 Review (v1.1)

Spring 2006 1 CS61A Midterm 2 Review (v1.1) Basic Info Your login: Your section number: Your TA s name: Midterm 2 is going to be held on Tuesday 7-9p, at 1 Pimentel. What will Scheme print? What will the

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

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

### A LISP Interpreter in ML

UNIVERSITY OF OSLO Department of Informatics A LISP Interpreter in ML Mandatory Assignment 1 INF3110 September 21, 2009 Contents 1 1 Introduction The purpose of this assignment is to write an interpreter,

### Basic Scheme February 8, Compound expressions Rules of evaluation Creating procedures by capturing common patterns

Basic Scheme February 8, 2007 Compound expressions Rules of evaluation Creating procedures by capturing common patterns Previous lecture Basics of Scheme Expressions and associated values (or syntax and

### This exam is worth 70 points, or about 23% of your total course grade. The exam contains 15 questions.

CS 61A Final Exam May 16, 2008 Your name login: cs61a This exam is worth 70 points, or about 23% of your total course grade. The exam contains 15 questions. This booklet contains 18 numbered pages including

### Scheme: Strings Scheme: I/O

Scheme: Strings Scheme: I/O CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Wednesday, April 5, 2017 Glenn G. Chappell Department of Computer Science University of

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

### (scheme-1) has lambda but NOT define

CS61A Lecture 12 2011-0-11 Colleen Lewis (calc) review (scheme-1) has lambda but NOT define Remember calc-apply? STk> (calc-apply '+ '(1 2 )) 6 STk> (calc-apply '* '(2 4 )) 24 STk> (calc-apply '/ '(10

### CS 61A Midterm #2 ver March 2, 1998 Exam version: A. Your name. login: cs61a- Discussion section number. TA's name

CS 61A Midterm #2 ver1.03 -- March 2, 1998 Exam version: A Your name login: cs61a- Discussion section number TA's name Look at the edge of your seat. Write your ROOM, seat row and number. Your row number

### Essentials of Programming Languages Language

Essentials of Programming Languages Language Version 5.3 August 6, 2012 The Essentials of Programming Languages language in DrRacket provides a subset of functions and syntactic forms of racket mostly

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

### Essentials of Programming Languages Language

Essentials of Programming Languages Language Version 6.90.0.26 April 20, 2018 The Essentials of Programming Languages language in DrRacket provides a subset of functions and syntactic forms of racket mostly

### CS 314 Principles of Programming Languages. Lecture 16

CS 314 Principles of Programming Languages Lecture 16 Zheng Zhang Department of Computer Science Rutgers University Friday 28 th October, 2016 Zheng Zhang 1 CS@Rutgers University Class Information Reminder:

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

### Discussion 4. Data Abstraction and Sequences

Discussion 4 Data Abstraction and Sequences Data Abstraction: The idea of data abstraction is to conceal the representation of some data and to instead reveal a standard interface that is more aligned

### CSC 533: Programming Languages. Spring 2015

CSC 533: Programming Languages Spring 2015 Functional programming LISP & Scheme S-expressions: atoms, lists functional expressions, evaluation, define primitive functions: arithmetic, predicate, symbolic,

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

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

### Well, Hal just told us how you build robust systems. The key idea was-- I'm sure that many of

MITOCW Lecture 3B [MUSIC PLAYING] Well, Hal just told us how you build robust systems. The key idea was-- I'm sure that many of you don't really assimilate that yet-- but the key idea is that in order

### Lecture 09: Data Abstraction ++ Parsing is the process of translating a sequence of characters (a string) into an abstract syntax tree.

Lecture 09: Data Abstraction ++ Parsing Parsing is the process of translating a sequence of characters (a string) into an abstract syntax tree. program text Parser AST Processor Compilers (and some interpreters)

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

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