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

Size: px
Start display at page:

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

Transcription

1 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 x y) (cons x y) (list x y) (b) Draw the tree structure corresponding to the following list. (1 ((2 3) 4) (5 6 7) (8 (9 10))) (c) Draw the box-and-pointer representation of the above list. 1

2 2 sum-leaves Write a Scheme procedure sum-leaves that takes one argument (a tree with integer leaves) and returns the sum of the leaves. 2

3 3 Match The code on the following pages implements a simple list matcher. The matcher is given two lists as input. The first list (the pattern) contains variables, and the second list (the data) does not. The procedure returns a list of variable bindings that would make the pattern match the data, if possible. Simple variables are denoted by symbols whose first character is a question mark, e.g.?x. Evaluate the following expressions: (match (a?x c) (a b c)) => (match (a (?x c) d) (a (b c) d)) => (match (a (?x c)?y) (a (b c) c)) => (match (a (b c) d) (a (b c) d)) => (match (a b c d) (a (b c) c)) => (match (a?x c?x e) (a b c b e)) => (match (a?x c?x e) (a b c d e)) => (match (a?x c?y e) (a b c d e)) => (match (a?x d) (a b c d)) => 3

4 ;;;; DATA STRUCTURES ;; Variables are indicated by?<var>, e.g.,?x. ;; Binding?<var>=<value> is represented by (?<var>. <value>) ;; in an association, e.g., ((?x. a), (?y. b)). ;; A pattern is a list of symbols and variables. ;; A datum is a list of symbols. (define (match p d) (do-match p d *no-bindings*)) ;; Arguments: Pattern (p), datum (d), bindings. ;; Returns: A list of bindings or #f (define (do-match p d bindings) (cond ((eq? p d) bindings) ;; is p down to one variable? ((variable? p) (match-variable p d bindings)) ((segment-variable? p) ;; A stand-alone segment variable (match *x...) is not well ;; defined. The more general case is caught by match-pair. *fail*) ((pair? p) (match-pair p d bindings)) (else *fail*))) ;; Arguments: Variable (var), datum (d), bindings. ;; Returns: A list of bindings or #f (define (match-variable var d bindings) (let ((binding (get-binding var bindings))) ;; Is the pattern variable on the list of bindings: (if binding ;; If it is, substitute its value and try again: (do-match (binding-val binding) d bindings) ;; Otherwise, add new binding: (extend-bindings var d bindings)))) 4

5 ;; Arguments: Pattern list (p), datum (d), bindings. ;; Returns: A list of bindings or #f (define (match-pair p d bindings) (if (segment-variable? (first p)) ;; to be implemented in Problem Set 1 (match-segment-variable p d bindings) (if (pair? d) ; p is a pair, so d better be (let ((result (do-match (first p) (first d) bindings))) ;; See if the FIRST parts match producing new bindings: (if (eq? result *fail*) ;; If they do not match, fail. *fail* ;; If they do match, try the REST parts using the ;; resulting bindings: (do-match (rest p) (rest d) result) )) *fail*))) ;;;; VARIABLE ABSTRACTION ;;; Is x a variable (a symbol beginning with? )? (define (variable? x) (and (symbol? x) (equal? (string-ref (symbol->string x) 0) #\?))) ;;; Is x a segment variable (a symbol beginning with * )? (define (segment-variable? x) (and (symbol? x) (equal? (string-ref (symbol->string x) 0) #\*))) ;;;; BINDINGS ABSTRACTION ;;; Indicates unification/match failure (define *fail* #f) ;;; Indicates unification/match success, with no variables. (define *no-bindings* ((#f))) 5

6 ;;; Find a (variable. value) pair in a binding list. (define (get-binding var bindings) (assoc var bindings)) ;;; Get the variable part of a single binding. (define (binding-var binding) (and binding (car binding))) ;;; Get the value part of a single binding. (define (binding-val binding) (and binding (cdr binding))) (define make-binding cons) ;;; Add a (var. value) pair to a binding list. (define (extend-bindings var val bindings) (cons (make-binding var val) ;; Once we add a "real" binding, ;; we can get rid of the dummy *no-bindings* (if (eq? bindings *no-bindings*) () bindings))) ;;;; HELPER FUNCTION ;;; Add elt to the end of lst. (define (add-to-end elt lst) (append lst (list elt))) (define rest cdr) 6

7 4 Scheme Quick Reference Scheme specification: Notation: <object> any Scheme data object. <object>* zero or more objects <object>+ one or more objects [<object>] optional object ( <whatever> )... Zero or more occurances of ( <whatever> ) Built-in Commands Signatures: (lambda <name> <exp>+ ) (lambda (<name>* ) <exp>+ ) (and <exp>*) (or <exp>*) (if <test-exp> <if-true> [<if-false>] ) (cond (<test> <exp>* )... [(else <exp>+)] ) (case <key-exp> ((<datum>+ ) <exp>* )... [(else <exp>+)] ) (define ( <name> <name>* ) <exp>+ ) (define <name> <exp> ) (let [<name>] ( (<vname> <value-exp>)... ) <exp>+ ) (let* ( (<vname> <value-exp>)... ) <exp>+ ) (letrec ( (<vname> <value-exp>)... ) <exp>+ ) (begin <expression>+ ) (do ( (<var> <init> <step>)... ) ( <test> <exp>* ) <exp>* ) (not <object>) (boolean? <object>) 7

9 (integer? <object>) (exact? <number>) (inexact? <number>) (= <number>+ ) (< <number>+ ) (> <number>+ ) (<= <number>+ ) (>= <number>+ ) (zero? <number>) (positive? <number>) (negative? <number>) (odd? <number>) (even? <number>) (max <number>+ ) (min <number>+ ) (+ <number>+ ) (* <number>+ ) (- <number>+ ) (/ <number>+ ) (abs <number>) (quotient <num1> <num2>) (remainder <num1> <num2>) (modulo <num1> <num2>) (gcd <number>* ) (lcm <number>* ) (numerator <rational>) (denominator <rational>) (floor <number>) (ceiling <number>) (truncate <number>) (round <number>) (rationalize <num1> <num2>) (exp <number>) (log <number>) (sin <number>) (cos <number>) (tan <number>) (asin <number>) (acos <number>) (atan <number> [<number>]) (sqrt <number>) (expt <num1> <num2>) (make-rectangular <num1> <num2>) (make-polar <num1> <num2>) (real-part <number>) (imag-part <number>) (magnitude <number>) (angle <number>) (exact->inexact <number>) (inexact->exact <number>) (number->string <number>) (string->number <string>) (char? <object>) (char=? <char1> <char2>) (char-ci=? <char1> <char2>) (char<? <char1> <char2>) (char-ci<? <char1> <char2>) (char>? <char1> <char2>) (char-ci>? <char1> <char2>) (char<=? <char1> <char2>) (char-ci<=? <char1> <char2>) (char>=? <char1> <char2>) (char-ci>=? <char1> <char2>) (char-alphabetic? <character>) (char-numeric? <character>) 9

10 (char-whitespace? <character>) (char-upper-case? <character>) (char-lower-case? <character>) (char->integer <character>) (integer->char <integer>) (char-upcase <character>) (char-downcase <character>) (string? <object>) (make-string <length> [<character>] ) (string <character>+ ) (string-length <string>) (string-ref <string> <index>) (string-set! <string> <index> <character>) (string=? <string1> <string2>) (string-ci=? <string1> <string2>) (string<? <string1> <string2>) (string-ci<? <string1> <string2>) (string>? <string1> <string2>) (string-ci>? <string1> <string2>) (string<=? <string1> <string2>) (string-ci<=? <string1> <string2>) (string>=? <string1> <string2>) (string-ci>=? <string1> <string2>) (substring <string> <start-index> <end-index>) (string-append <string>+ ) (vector? <object>) (make-vector <length> [<object>] ) (vector <object>* ) (vector-length <vector>) (vector-ref <vector> <index>) (vector-set! <vector> <index> <object>) (procedure? <object>) (apply <procedure> <arg>* <arg-list>) (map <procedure> <list>+ ) (for-each <procedure> <list>+ ) (call-with-current-continuation <one-argument-procedure>) (call-with-input-file <string> <procedure>) (call-with-output-file <string> <procedure>) (input-port? <object>) (output-port? <object>) (current-input-port) (current-output-port) (open-input-file <string>) (open-output-file <string>) (close-input-port <input-port>) (close-output-port <output-port>) (eof-object? <object>) (read [<input-port>] ) 10

11 (read-char [<input-port>] ) (peek-char [<input-port>] ) (write <object> [<output-port>] ) (display <object> [<output-port>] ) (newline [<output-port>] ) (write-char <character> [<output-port>] ) (list-tail <list> <index>) (string->list <string>) (list->string <list-of-characters>) (string-copy <string>) (string-fill! <string> <character>) (vector->list <vector>) (list->vector <list>) (vector-fill! <vector> <object>) (delay <expression>) (force <promise>) (with-input-from-file <string> <thunk>) (with-output-to-file <string> <thunk>) (char-ready? [<input-port>] ) (load <string>) (transcript-on <string>) (transcript-off) 11

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

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

### How to Design Programs Languages

How to Design Programs Languages Version 4.1 August 12, 2008 The languages documented in this manual are provided by DrScheme to be used with the How to Design Programs book. 1 Contents 1 Beginning Student

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

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

### How to Design Programs Languages

How to Design Programs Languages Version 6.6 July 22, 2016 The languages documented in this manual are provided by DrRacket to be used with the How to Design Programs book. When programs in these languages

### Artificial Intelligence Programming

Artificial Intelligence Programming Rob St. Amant Department of Computer Science North Carolina State University Lisp basics NC State University 2 / 99 Why Lisp? Some recent Lisp success stories include

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

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

### Scheme->C Index to the Report on the Algorithmic Language Scheme 15 March 1993

Scheme->C Index to the Report on the Algorithmic Language Scheme 15 March 1993 Implementation Notes bit-and bit-lsh bit-not bit-or bit-rsh bit-xor Scheme->C is an implementation of the language c-byte-ref

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

### CSE 341 Section Handout #6 Cheat Sheet

Cheat Sheet Types numbers: integers (3, 802), reals (3.4), rationals (3/4), complex (2+3.4i) symbols: x, y, hello, r2d2 booleans: #t, #f strings: "hello", "how are you?" lists: (list 3 4 5) (list 98.5

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

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

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

### INTRODUCTION TO SCHEME

INTRODUCTION TO SCHEME PRINCIPLES OF PROGRAMMING LANGUAGES Norbert Zeh Winter 2019 Dalhousie University 1/110 SCHEME: A FUNCTIONAL PROGRAMMING LANGUAGE Functions are first-class values: Can be passed as

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

### ;;; Determines if e is a primitive by looking it up in the primitive environment. ;;; Define indentation and output routines for the output for

Page 1/11 (require (lib "trace")) Allow tracing to be turned on and off (define tracing #f) Define a string to hold the error messages created during syntax checking (define error msg ""); Used for fancy

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

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

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

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

### CSc 520. Principles of Programming Languages 7: Scheme List Processing

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

### CSc 520 Principles of Programming Languages. Examining Lists. Constructing Lists... 7: Scheme List Processing

Constructing Lists CSc 520 Principles of Programming Languages 7: Scheme List Processing Christian Collberg collberg@cs.arizona.edu Department of Computer Science University of Arizona The most important

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

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

### Things Your Mother Never Told You About AutoLISP Phil Kreiker - Looking Glass Microproducts

November 30 - December 3, 2004 Las Vegas, Nevada hings Your Mother Never old You About AutoLISP Phil Kreiker - Looking Glass Microproducts CP41-4 Now that you are acquainted with AutoLISP, we'll introduce

### Scheme as implemented by Racket

Scheme as implemented by Racket (Simple view:) Racket is a version of Scheme. (Full view:) Racket is a platform for implementing and using many languages, and Scheme is one of those that come out of the

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

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

### Important Example: Gene Sequence Matching. Corrigiendum. Central Dogma of Modern Biology. Genetics. How Nucleotides code for Amino Acids

Important Example: Gene Sequence Matching Century of Biology Two views of computer science s relationship to biology: Bioinformatics: computational methods to help discover new biology from lots of data

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

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

### SRFIs: Libraries. Version August 10, 2015

SRFIs: Libraries Version 6.2.1 August 10, 2015 The Scheme Requests for Implementation (a.k.a. SRFI) process allows individual members of the Scheme community to propose libraries and extensions to be supported

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

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

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

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

### Text File Databases. Contents. Appendices 7 Source code... 7 Test code Input file readers

Text File Databases Contents 1 Input file readers 1 1.1 Fixed-length data fields............ 2 1.2 Character-delimited fields........... 2 1.3 Comma-separated values............ 2 1.4 Name-value data................

### 6.001: Structure and Interpretation of Computer Programs

6.001: Structure and Interpretation of Computer Programs Symbols Quotation Relevant details of the reader Example of using symbols Alists Differentiation Data Types in Lisp/Scheme Conventional Numbers

### More Scheme CS 331. Quiz. 4. What is the length of the list (()()()())? Which element does (car (cdr (x y z))) extract from the list?

More Scheme CS 331 Quiz 1. What is (car ((2) 3 4))? (2) 2. What is (cdr ((2) (3) (4)))? ((3)(4)) 3. What is (cons 2 (2 3 4))? (2 2 3 4) 4. What is the length of the list (()()()())? 4 5. Which element

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

### Lists in Lisp and Scheme

Lists in Lisp and Scheme a Lists in Lisp and Scheme Lists are Lisp s fundamental data structures, but there are others Arrays, characters, strings, etc. Common Lisp has moved on from being merely a LISt

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

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

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

### CSE 341 Lecture 16. More Scheme: lists; helpers; let/let*; higher-order functions; lambdas

CSE 341 Lecture 16 More Scheme: lists; helpers; let/let*; higher-order functions; lambdas slides created by Marty Stepp http://www.cs.washington.edu/341/ Lists (list expr2... exprn) '(value1 value2...

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

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

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,

### FUNKCIONÁLNÍ A LOGICKÉ PROGRAMOVÁNÍ 3. LISP: ZÁKLADNÍ FUNKCE, POUŽÍVÁNÍ REKURZE,

FUNKCIONÁLNÍ A LOGICKÉ PROGRAMOVÁNÍ 3. LISP: ZÁKLADNÍ FUNKCE, POUŽÍVÁNÍ REKURZE, 2011 Jan Janoušek MI-FLP Evropský sociální fond Praha & EU: Investujeme do vaší budoucnosti Comments in Lisp ; comments

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

### Functional Programming Languages (FPL)

Functional Programming Languages (FPL) 1. Definitions... 3 2. Applications... 3 3. Examples... 4 4. FPL Characteristics:... 5 5. Lambda calculus (LC)... 6 5.1. LC expressions forms... 6 5.2. Semantic of

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

### Racket Values. cons Glues Two Values into a Pair. The Pros of cons: Pairs and Lists in Racket. Box-and-pointer diagrams for cons trees

The Pros of cons: in Racket CS251 Programming Languages Fall 2018, Lyn Turbak Department of Computer Science Wellesley College booleans: #t, #f numbers: integers: 42, 0, -273 ra3onals: 2/3, -251/17 floa3ng

### Lecture Notes on Lisp A Brief Introduction

Why Lisp? Lecture Notes on Lisp A Brief Introduction Because it s the most widely used AI programming language Because Prof Peng likes using it Because it s good for writing production software (Graham

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

### CS 61A, Fall, 2002, Midterm #2, L. Rowe. 1. (10 points, 1 point each part) Consider the following five box-and-arrow diagrams.

CS 61A, Fall, 2002, Midterm #2, L. Rowe 1. (10 points, 1 point each part) Consider the following five box-and-arrow diagrams. a) d) 3 1 2 3 1 2 e) b) 3 c) 1 2 3 1 2 1 2 For each of the following Scheme

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:

Teach Yourself Scheme in Fixnum Days c Dorai Sitaram, 1998 2004 All Rights Reserved ds26 at gte.com Contents Preface, 2 1 Enter Scheme, 3 2 Data types, 5 2.1 Simple data types, 6 2.1.1 Booleans, 6 2.1.2

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

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

### 6.001 recitation 3/21/07

6.001 recitation 3/21/07 set-car! and set-cdr! ring problems more set-car!, set-cdr! problems 2 Dr. Kimberle Koile compound data mutation constructor: (cons x y) creates a new pair selectors: (car p) (cdr

### Simplifying Logical Formulas

Simplifying Logical Formulas Assume we have a SCHEME logical expression involving the operators and, or, not, and the truth constants #t and (). Example: (and a (not b) (or b c) (not (and c (not d))) #t

### Common Lisp. Blake McBride

Contents Common Lisp Blake McBride (blake@mcbride.name) 1 Data Types 2 2 Numeric Hierarchy 3 3 Comments 3 4 List Operations 4 5 Evaluation and Quotes 5 6 String Operations 5 7 Predicates 6 8 Math Predicates

### ECE570 Lecture 2: Types and Conventions

ECE570 Lecture 2: Types and Conventions Jeffrey Mark Siskind School of Electrical and Computer Engineering Fall 2017 Siskind (Purdue ECE) ECE570 Lecture 2: Types and Conventions Fall 2017 1 / 28 Booleans

### Racket Values. cons Glues Two Values into a Pair. The Pros of cons: Programming with Pairs and Lists. Box-and-pointer diagrams for cons trees

The Pros of cons: Programming with CS251 Programming Languages Fall 2017, Lyn Turbak Department of Computer Science Wellesley College booleans: #t, #f numbers: integers: 42, 0, -273 ra3onals: 2/3, -251/17

### ECE473 Lecture 2: Types and Conventions

ECE473 Lecture 2: Types and Conventions Jeffrey Mark Siskind School of Electrical and Computer Engineering Spring 2019 Siskind (Purdue ECE) ECE473 Lecture 2: Types and Conventions Spring 2019 1 / 28 Booleans

### MORE SCHEME. 1 What Would Scheme Print? COMPUTER SCIENCE MENTORS 61A. October 30 to November 3, Solution: Solutions begin on the following page.

MORE SCHEME COMPUTER SCIENCE MENTORS 61A October 30 to November 3, 2017 1 What Would Scheme Print? Solutions begin on the following page. 1. What will Scheme output? Draw box-and-pointer diagrams to help

### CS61A Summer 2010 George Wang, Jonathan Kotker, Seshadri Mahalingam, Eric Tzeng, Steven Tang

CS61A Notes Week 6B: Streams Streaming Along A stream is an element and a promise to evaluate the rest of the stream. You ve already seen multiple examples of this and its syntax in lecture and in the

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

### R6RS: Scheme. Version February 2, 2012

R6RS: Scheme Version 5.2.1 February 2, 2012 The The Revised 6 Report on the Algorithmic Language Scheme defines a dialect of Scheme. We use R 6 RS to refer to both the standard and the language defined

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

### Pattern Matching for Scheme

Pattern Matching for Scheme Andrew K. Wright March 1996 Department of Computer Science MS 132 Rice University 6100 Main Street Houston, Texas 77005-1892 Contents 1 Match 1 1.1 Definition... 1 1.1.1 Patterns...

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

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

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

### Box-and-arrow Diagrams

Box-and-arrow Diagrams 1. Draw box-and-arrow diagrams for each of the following statements. What needs to be copied, and what can be referenced with a pointer? (define a ((squid octopus) jelly sandwich))

### Kent Dybvig, Will Clinger, Matthew Flatt, Mike Sperber, and Anton van Straaten

R6RS Status Report Kent Dybvig, Will Clinger, Matthew Flatt, Mike Sperber, and Anton van Straaten June 21, 2006 1. Overview This status report describes the current state of the R 6 RS standardization

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

### 6.001, Spring Semester, 1998, Final Exam Solutions Your Name: 2 Part c: The procedure eval-until: (define (eval-until exp env) (let ((return (eval-seq

1 MASSACHVSETTS INSTITVTE OF TECHNOLOGY Department of Electrical Engineering and Computer Science 6.001 Structure and Interpretation of Computer Programs Spring Semester, 1998, Final Exam Solutions Your

### Allegro CL Certification Program

Allegro CL Certification Program Lisp Programming Series Level I Session 1.3.1 David Margolies Manipulating Lists 9/16/2010 1 What is a List? An ordered (possibly empty) collection of things in a particular

### It is better to have 100 functions operate one one data structure, than 10 functions on 10 data structures. A. Perlis

Chapter 14 Functional Programming Programming Languages 2nd edition Tucker and Noonan It is better to have 100 functions operate one one data structure, than 10 functions on 10 data structures. A. Perlis

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

### Sample midterm 1 #1. Problem 1 (What will Scheme print?).

Sample midterm 1 #1 Problem 1 (What will Scheme print?). What will Scheme print in response to the following expressions? If an expression produces an error message, you may just say error ; you don t

### (Func&onal (Programming (in (Scheme)))) Jianguo Lu

(Func&onal (Programming (in (Scheme)))) Jianguo Lu 1 Programming paradigms Func&onal No assignment statement No side effect Use recursion Logic OOP AOP 2 What is func&onal programming It is NOT what you

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

### CSCI337 Organisation of Programming Languages LISP

Organisation of Programming Languages LISP Getting Started Starting Common Lisp \$ clisp i i i i i i i ooooo o ooooooo ooooo ooooo I I I I I I I 8 8 8 8 8 o 8 8 I \ `+' / I 8 8 8 8 8 8 \ `-+-' / 8 8 8 ooooo

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

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

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

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

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

### CSE 413 Midterm, May 6, 2011 Sample Solution Page 1 of 8

Question 1. (12 points) For each of the following, what value is printed? (Assume that each group of statements is executed independently in a newly reset Scheme environment.) (a) (define x 1) (define

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