# Introductory Scheme. Revision 1

Size: px
Start display at page:

Transcription

1 Introductory Scheme Revision 1 Joseph W. Lavinus and James D. Arthur and Department of Computer Science Virginia Polytechnic Institute and State University Blacksburg, Virginia May 6, 1993 Abstract This document is an introductory guide to applicative programming using the language Scheme, a modern dialect of Lisp. It assumes familiarity with computers and with basic programming techniques, but no knowledge of Lisp or applicative programming. This manual describes a purely functional subset of Scheme, the use of the XScheme interpreter, and some style guidelines and programming tips. 1

2 Contents 1 Introduction 3 2 The Interpreter 4 3 Basics 5 4 Predicates 8 5 Control 10 6 Math Operations 11 7 Defining Functions 13 8 Binding 14 9 Functions are First-Class Examples Development and Debugging Style Guidelines REFERENCES 23 A Installation 24 B Reference 25 2

3 1 Introduction Scheme is a small, versatile dialect of Lisp. Like Lisp, it is an applicative or functional language. This means that, unlike imperative languages, which are made up of sequences of instructions, applicative programs are based solely on functions and their return values. The only means of control is recursion. Functional languages are characterized by their lack of side effects, which are operations that change the state of some variable or environment. That is, an operation never modifies its argument; instead, it returns a copy of that argument that is identical to the original argument except for the changes specified by the function. This provides a property called referential transparency, which means that a function called with the same arguments will always exhibit the same behavior. Functions in imperative languages may depend on side effects or global variables, and thus referential transparency need not hold. Section 2 describes the XScheme interpreter, its invocation, and a few control primitives for using the interpreter. Section 3 describes some fundamentals of the Scheme language, such as atoms, lists, and evaluation. Section 4 describes the boolean predicates available in Scheme, and Section 5 goes on to describe the control structures provided. Section 6 describes the mathematical operations provided in Scheme. Section 7 describes function definition, and Section 8 describes variable bindings and the use of local and global variables. Section 9 describes functions as first-class, i.e., using functions as arguments to, or return values from, functions, and also discusses unnamed (lambda) functions. Section 10 provides two programs as explanatory examples. Section 11 discusses some hints and techniques for simplifying the development and debugging process. Finally, Section 12 provides a few style guidelines and tips for programming in Scheme. 3

4 2 The Interpreter Scheme is an interpreted, or interactive, language, meaning that expressions are entered into the interpreter one at a time, at which time the interpreter immediately evaluates them and outputs the result. The XScheme interpreter is invoked from the command prompt by typing xscheme, like so (this assumes that you have already unpacked and installed the XScheme interpreter; if not, Appendix A provides instructions on how to do so): % xscheme XScheme - Version 0.22 > The > symbol is the prompt, which is the interpreter s way of saying, give me an expression to evaluate. The following system-level constructs are provided for manipulation of the interpreter and the programming environment (Section 11 describes the development process and debugging tips in detail): (exit) Exit the compiler and return to the operating system shell. (load "filename") Load the text in the file specified by filename, just as though it was entered from the keyboard. The customary way to write Scheme programs is to enter the function definitions in a text file using a text editor such as vi or emacs, and then to load that text file in this fashion. Scheme files generally are given the extension.scm. (reset) The XScheme interpreter, upon encountering an error condition, enters an error-level state. The reset command returns the interpreter to the top level, where one may continue programming as usual. (transcript-on "filename") Turns on the transcripting feature, in which all text entered from the keyboard, and all text output from the interpreter, is echoed to filename. This is useful for recording sample runs and the like. Typing (transcript-off) turns off the transcripting and closes filename. 4

5 3 Basics Everything in Scheme, both programs and data, is an S-expression. An S-expression may have one of two types, an atom or a list. Atoms, as the name suggests, are the fundamental objects in Scheme. An atom may be a number, a symbol, or nil (which is synonymous with the empty list, which we ll talk about in a moment). A fundamental distinction to the Scheme interpreter is whether or not an object should be evaluated. Numbers always evaluate to themselves, so this distinction is not important for numeric atoms, such as 27 or However, for symbols and lists, this distinction is very important. A symbol, for instance, may be either a literal (if it should remain unevaluated), or a variable name (if evaluated). The quote function controls whether or not an S-expression should be evaluated; for instance, the atom foo is a variable named foo, while (quote foo) evaluates to a literal symbol foo. In addition, (quote expression) may be abbreviated expression. Throughout this manual, we use a double right arrow ( ) to denote evaluates to. For instance, the following relations denote the behavior of the Scheme interpreter for the atoms we have just discussed: foo foo (quote foo) foo foo error: undefined variable 3.1 Lists A list is a sequence of S-expressions, separated by whitespace (spaces, tabs, newlines, and formfeeds), and surrounded by parentheses. Note that each S-expression can itself be a list, so the following are all valid lists: (1 2 3), (1 (2 3)), (1 (2 (3))), etc. In addition, a special list is defined that has no elements. This is called the empty list, or the null list, and is written () or nil. Lists may be left unevaluated in the same manner as atoms, by quoting them. (1 2 3) (1 2 3) If a list is to be evaluated, its first element is considered to be a function name, and the remaining elements are arguments to that function. The number of arguments a function expects is called its arity. For instance, the addition function is called +, and it has an arity of two. For example, (+ 2 3) 5 5

6 As with all lists, the arguments to a function may themselves be function calls. For example, (+ (+ 2 3) (+ 5 6)) List Manipulation Scheme, like all Lisp dialects, considers lists to be accessible only from the front (internally, they are represented as linked lists). Thus, Scheme provides a number of functions for accessing the first element of a list (the head), the rest of the list not including the head (the tail), inserting a new head, and so forth. We describe these here. The car function, given a list, returns the head of that list. Note that the head of a list need not be an atom. (car (1 2 3)) 1 (car ((1 2) 3) (1 2) Similarly, the cdr function returns the tail of a list. This return value is always a list. (cdr (1 2 3)) (2 3) (cdr ((1 2) 3)) (3) (cdr (1 (2 3))) ((2 3)) (cdr (1)) () Applying car or cdr to an empty list is an error 1. The cons function is used for list construction; given an element and a list, it creates a new list identical to its list argument, but with the element added as the new head. (cons 1 (2 3)) (1 2 3) (cons (1 2) (3 4) ((1 2) 3 4) The list function creates a list from a set of s-expressions. It takes a variable number of arguments, and merely formulates those arguments into a list. (list 1 2 3) (1 2 3) (list (1 2) 3) ((1 2) 3) Several other useful list manipulations are provided as well: append, reverse, and length. Note that these are not primitives; they may easily be defined using the primitives described above. 1 This is not really true; see Section 12 6

7 The append function merely concatenates two lists. (append (1 2) (3 4)) ( ) The reverse function reverses the order of elements in a list. (reverse (1 2 3)) (3 2 1) The length function returns the length of the list in elements. Note that this does not include elements of any sublists; it merely counts the number of s-expressions that make up the list. (length (1 2 3)) 3 (length ((1 2) 3)) 2 7

8 4 Predicates Predicates in Scheme are boolean operators. They return either true, denoted #t, or false, denoted by the empty list, (). The predicates defined in Scheme are: (atom? expression) Returns true if expression is an atom, or the empty list, false otherwise. (atom? a) #t (atom? 12) #t (atom? (1 2 3)) () (atom? ()) #t (list? expression) Returns true if expression is a list, including the empty list. Note that the empty list is the only expression that returns true for both atom? and list?. (list? (1 2 3)) #t (list? a) () (list? ()) #t (null? expression) Returns true only if expression is the empty list, () or nil. (null? ()) #t (null? (1 2 3)) () (null? a) () (not predicate) Returns true if predicate returns (), false otherwise. (not ()) #t (not #t) () (equal? expression1 expression2) Returns true if expression1 and expression2 are structurally equivalent; that is, if they have the same list structure and all their atoms are equal. This is not to be confused with eq?, which returns true only if its arguments are the same object. That is, equal? tests for structural equivalence, while eq? tests for pointer equivalence. In the following examples, assume that we have already entered (define foo ((1 2) 3)). 8

9 (equal? ((1 2) 3) ((1 2) 3)) #t (eq? ((1 2) 3) ((1 2) 3)) #t (equal? ((1 2) 3) foo) #t (eq? ((1 2) 3) foo) () (equal? foo foo) #t (eq? foo foo) #t (and predicate1 predicate2) Returns true if predicate1 and predicate2 both return true, false otherwise. (or predicate1 predicate2) Returns true if either predicate1 or predicate2 return true, or false if neither of them return true. 4.1 Numerical Predicates In all the following examples, e n denotes an expression that returns a numerical value. (= e 1 e 2 ) Returns true if the two numbers are equal. (< e 1 e 2 ) Returns true if e 1 is numerically less than e 2. (> e 1 e 2 ) Returns true if e 2 is numerically greater than e 1. (<= e 1 e 2 ) Returns true if e 1 is numerically less than or equal to e 2. (>= e 1 e 2 ) Returns true if e 2 is numerically greater than or equal to e 1. 9

10 5 Control The fundamental selection function in Scheme is cond. The format of cond is as follows: (cond (predicate1 consequent1) (predicate2 consequent2)... (predicaten consequentn)) The cond function evaluates the predicates of its arguments from left to right, and when predicatei evaluates to true, it evaluates consequenti and offers its return value as the return value of the cond. An error occurs if no predicate evaluates to true; often, predicaten is else, a predicate variable that always has value true, such that consequentn is evaluated if none of the others are true. The if construct is a special case of cond, where there are only two possibly paths of execution. The format of the if is as follows: (if predicate then-part else-part) In the if construct, predicate is tested; if it returns true, then then-part is evaluated and its value returned as the value of the if; otherwise, else-part is evaluated and its value is returned as the value of the if. 10

11 6 Math Operations As has been described earlier, math functions are called in the same manner as all other functions: a list whose first element is a math operator, and the rest of whose elements are arguments to that operator. The following math operators are defined: (+ n 1 n 2 ) Addition: returns n 1 + n 2. (+ 2 3) 5 ( ) 3.85 (- n 1 n 2 ) Subtraction: returns n 1 n 2. (- 5 2) 3 ( ) 1.4 (* n 1 n 2 ) Multiplication: returns n 1 n 2. (* 3 5) 15 (* ) 3.75 (/ n 1 n 2 ) Division: returns n 1 n 2. (/ 8 2) 4 (/ 1.5 3) 0.5 (quotient n 1 n 2 ) Integer division: returns the integer portion of n 1 n 2. (quotient 9 4) 2 (quotient 9 3) 3 (remainder n 1 n 2 ) Remainder: returns the remainder that results from the division of n 1 by n 2, or n 1 mod n 2. (remainder 9 4) 1 (remainder 9 3) 0 11

12 (sqrt n) Square root: returns n. (sqrt 4) 2 (sqrt 2) (expt n 1 n 2 ) Exponentiation: returns n 1 n 2. (expt 2 3) 8 (expt 4 0.5) 2 12

13 7 Defining Functions The define function is used to define functions. For format of define is: (define (name args) body) Where args is a list of arguments arg1 arg2... argn, and body is the body of the function. When the function is called, via (name arg1 arg2... argn), the actual arguments in the call are bound to the formal arguments in the define, which act as local variables within body. For example, the ever-popular factorial function would be defined as follows (n factorial is equal to n (n 1) (n 2)... 1, and 0 factorial is defined to equal 1): (define (fact n) (cond ((= n 0) 1) (else (* n (fact (- n 1)))))) A call to this function with n equal to 3 proceeds as follows: (fact 3) (* 3 (fact 2)) (* 3 (* 2 (fact 1))) (* 3 (* 2 (* 1 (fact 0)))) (* 3 (* 2 (* 1 1))) 6 A function with a variable number of arguments is defined as follows: (define (name args. rest) body) Within body, the arguments arg1 arg2... argn are bound to the first N arguments to the function, and any remaining arguments are bound as a list to rest. 13

14 8 Binding Within a function, the arguments in the define statement are scoped as local variables, whose values are determined by the actual arguments in the call to that function. In addition, we may use define to declare global variables, and we may also use a construct called let to declare local variables in addition to those given as arguments. Global variables may be defined as follows: (define name value) This assigns value to a the variable name. In actuality, this operation defines a function called name, of arity 0, that always returns value. It should be noted that, as in imperative programming, global variables should be avoided except in the role of constants. That is, it is acceptable to define global variables within a Scheme program, but it is never acceptable to redefine them. Local variables may be declared using the let construct. The syntax of let is as follows: (let ((var1 init1) (var2 init2)... (varn initn)) body) Within body, var1 is assigned value init1, var2 is assigned init2, and so on. Body is evaluated within the scope of these variables, and its value is returned as the value of the let. 14

15 9 Functions are First-Class In Scheme, as in most dialects of Lisp, functions are first-class. This means that they are values, just like any other data type they may be passed as arguments to functions and returned as values of functions. This is one of the most powerful aspects of Scheme. One construct that is useful when passing functions as arguments is lambda. This gives one the capability to define functions without names. The lambda statement has the same syntax as the define statement, but without a function name. For instance, (lambda (x) (+ 5 x)), when evaluated, returns a function of one argument, that adds five to that argument. That is, ((lambda (x) (+ 5 x)) 10) 15 This allows us, for example, to define a function called map that applies some function to each element of a list: (define (map fn l1) (cond ((null? l1) ()) (else (cons (fn (car l1)) (map fn (cdr l1)))))) We may now apply map like so: (map (lambda (x) (+ 1 x)) (1 2 3)) (2 3 4) (map (lambda (x) (* 2 x)) (1 2 3)) (2 4 6) (map (lambda (x) (list x)) (1 2 3)) ((1) (2) (3)) (map sqrt (1 4 9)) (1 2 3) 15

16 10 Examples 10.1 Example One: Flatten The flatten function, given a list, returns a list of the atoms in that list. In other words, it flattens the recursive list structure of its argument. For instance, (flatten (1 2 3)) (1 2 3) (flatten ((1 2) 3) (1 2 3) (flatten ((1) (2) (3)) (1 2 3) (flatten ()) () (flatten ((()))) () The flatten function may be defined as follows: (define (flatten l1) (cond ((null? l1) ()) ((null? (car l1)) (flatten (cdr l1))) ((atom? (car l1)) (cons (car l1) (flatten (cdr l1)))) (else (append (flatten (car l1)) (flatten (cdr l1)))))) This function works in the following way: 1. We define a function flatten that takes one argument, l1. 2. We branch using a cond statement, dependent on qualities of l1. 3. If l1 is empty, we return the empty list; (flatten ()) (). In functions that operate on lists, checking the argument for null? is typically the base case of the recursion, and the first branch of the cond. 4. If the first element in l1 is the empty list, i.e., l1 looks like (()... ), we throw away that element and return the flatten of the tail of l1. 5. If the first element is an atom, it cannot be the empty list, since that case was captured by the previous branch. Thus, it is a normal atom, and we return that atom cons ed onto the flatten of the tail of l1. 6. Lastly, if none of the previous cases were true, the first element of l1 is itself a non-empty list, and we return the flatten of that list appended to the flatten of the tail of l1. 16

17 10.2 Example Two: Quicksort The Quicksort algorithm may be easily defined in Scheme. For those not familiar with this algorithm, Quicksort sorts a list (in this case, a list of numbers) in the following manner: 1. If the list is empty, it is obviously already sorted, so we merely return it. Otherwise Choose a pivot. The easiest way is to choose the first element of the list as the pivot. 3. Partition the list into three sublists: the elements in the list that are less than the pivot, the elements that are equal to the pivot, and the elements that are greater than the pivot. 4. Recursively call Quicksort to sort the list of lesser elements and the list of greater elements. The list of equal elements all have the same value, so it is already sorted. 5. Concatenate the sorted list of lesser elements, the list of equal elements, and the sorted list of greater elements, and return it as the sorted list. This may be written in Scheme as follows: (define (partition compare l1) (cond ((null? l1) ()) ((compare (car l1)) (cons (car l1) (partition compare (cdr l1)))) (else (partition compare (cdr l1))))) (define (quicksort l1) (cond ((null? l1) ()) (else (let ((pivot (car l1))) (append (append (quicksort (partition (lambda (x) (< x pivot)) l1)) (partition (lambda (x) (= x pivot)) l1)) (quicksort (partition (lambda (x) (> x pivot)) l1))))))) The partition function in this example illustrates the usefulness of passing functions as arguments; by doing so, we may use the same partition function for both the lesser and greater sublists. The function does this by taking a predicate function compare, which should return true or false, and a list, l1. If l1 is the empty list, it returns the empty list. Otherwise, if the first element in l1 returns true when compare is applied to it, we return that first element cons ed onto the partition of the tail of l1. If compare returns false, we fall through to the last condition, in which we merely return the partition of the tail of l1, without the first element of l1. Then, in the actual quicksort function, we perform the following actions: If l1 is the empty list, we return the empty list. Otherwise, we bind a local variable pivot to the first element in l1. We then find the list of elements less than pivot by passing the function (lambda (x) (< x pivot)) to partition. 17

18 This lambda function returns true if its argument, x, is less than pivot. Thus, passing this function to partition results in the list of elements in l1 that are less than pivot. We similarly use partition to form the list of elements equal to pivot and the list of elements greater than pivot. We the recursively apply the quicksort function to the list of lesser elements and the list of greater elements, and then append the three results together. 18

19 11 Development and Debugging This section describes some techniques the authors have found useful in the development and debugging process. Unix 2 redirection can be useful in testing programs and producing sample output. As with most applications, XScheme may take its input from a file instead of the keyboard, and may send its output to a file instead of to the screen. File input is especially useful, since it allows one to assemble a file of test cases and redirect them into the interpreter, rather than retyping them every time one wants to test the program. For instance, suppose we have typed the Quicksort program from Section 10.2, and stored it in the file qsort.scm. We may test the program, and obtain output for these test cases, by creating a file like the following: (load "qsort.scm") (transcript-on "qsort.out") (qsort ( )) (qsort ( )) (qsort ( )) (qsort ( )) (transcript-off) (exit) And then, supposing we named this file qsort.in, we may redirect it into the XScheme interpreter like so: % xscheme < qsort.in Note that the last command in the file is (exit). This exits the XScheme interpreter when the commands in the file is completed. Be careful to include (exit) as the last command in all such test files, as without it, the interpreter will hang, waiting for further input. After this operation completes, the transcript of the test cases and their output will be in qsort.out. Output may also be saved to a file by using redirection rather than transcripting, but this method does not echo the test input to the file, so transcripting is preferred. Debugging is a little tricky. In a sequential language, one often debugs a program by strategically inserting output statements throughout the program to examine the values of variables, to follow flow of control, and so forth. Scheme lacks this sequentiality, so merely inserting an output statement is impossible. However, Scheme offers a construct that allows such sequential execution, called begin. Its format is merely: (begin expression1 expression2... expressionn) In the begin construct, the expressions are evaluated from left to right, and the value of expressionn is returned as the value of the begin construct. One can easily see that such a construct is meaningless unless 2 Unix is a registered trademark of AT&T Information Systems 19

20 the first N 1 expressions have side effects, i.e., they destructively modify the state of some variable (an action that, for our purposes, is considered forbidden) or perform some I/O. This is the purpose for which we will use it: for debugging purposes, we may replace some expression with (begin print-statement expression). This will execute print-statement, then evaluate expression and return its value as the value of the begin; thus, except for the output of print-statement, this modification is transparent in the evaluation of the program. The output statement in XScheme is merely (write expression). This prints the value of expression to the standard output. For example, write statement Printed to standard output (write 13) 13 (write a) a (write "foo") "foo" (write (1 2 3)) (1 2 3) The function (newline) writes a newline character to the standard output. For example, suppose we replace the entire body of the flatten function described in Section 10.1 with the following: (begin (write l1) (newline) body) Then, when we call the flatten function, we get output something like this: > (flatten ((1 (2)) 3 (4) () 5)) ((1 (2)) 3 (4) () 5) (3 (4) () 5) ((4) () 5) (() 5) (5) () (4) () (1 (2)) ((2)) () (2) () ( ) > Lastly, it should be noted that Control-C will interrupt the XScheme interpreter and drop you back to the operating system at any time. 20

21 12 Style Guidelines This section discusses some style guidelines for Scheme, constructs to avoid, and pointers on good programming style and efficiency. 1. Variable naming. In Scheme, variables must begin with a letter, and all subsequent characters may be letters, numbers, or any of the following: + -. * / < = >!? : \$ % _ & ~ ^ The length of variable names is unrestricted. Thus, one should choose descriptive variable names, avoiding abbreviations whenever practical. Customarily, predicates end with a?, with a few exceptions, such as the numerical predicates. 2. Assignment forms. Scheme does provide an assignment operator, set!. In addition, Scheme provides destructive versions of many functions; for instance, append!, given two lists, destructively appends the second list to the end of the first. These side-effecting functions are called assignment forms, and their names usually end with!. While they are often used in real applications, from the point of view of functional programming, they should be considered forbidden. 3. cadadr and friends. Scheme provides compositionsof car and cdr formed by inserting appropriate a s and d s between the c and the r. For instance, (cadr l1) denotes (car (cdr l1)). These compositions should be avoided, especially the longer ones. It is doubtful that anyone, even accomplished Scheme programmers, has an intuitive feel for what cadadr means, and using such forms generally means you are doing something in an ugly way. 4. Pretty-printing. Most Scheme programmers lay out their functions as I have throughout this manual, indenting the appropriate function calls and adding all the closing parentheses at the end, like so: (define (append l1 l2) (cond ((null? l1) l2) (else (cons (car l1) (append (cdr l1) l2))))) To simplify matching parentheses, however, you may find it convenient to line up the closing parentheses with the expression they are closing, as with the brackets in C, like so: (define (append l1 l2) (cond ((null? l1) l2) (else (cons (car l1) (append (cdr l1) l2))) ) ) This is purely a matter of personal preference. 21

22 5. Applying car and cdr to the empty list. In many implementations of Scheme, including XScheme, applying car or cdr to the empty list is valid, and returns nil in both cases. However, this behavior is not specified in the Scheme standards, and in other implementations it may cause an error or a warning. Thus, for reasons of portability and general good programming style, one should avoid situations in which (car ()) or (cdr ()) get evaluated. 6. Sequential constructs. Scheme offers a construct for sequential programming called begin. This allows sequential execution of a number of Scheme statements, with the return value of the begin being the last statement executed within its body. In addition, some constructs, such as let, perform an implicit begin. This should be avoided (except for its use in debugging, as described in Section 11), and is basically useless in the absence of assignment forms anyway. 22

23 13 REFERENCES [1] Abelson, Hal and Gerard Sussman, Structure and Interpretation of Computer Programs, McGraw- Hill, [2] Betz, David, XScheme: An Object-Oriented Scheme, v0.17, [3] Bloss, Adrienne, CS5314 Class Notes, Virginia Polytechnic Institute and State University, Fall [4] Clinger, William and Jonathan Rees (eds.), Revised 3 99 Reporton the AlgorithmicLanguage Scheme, [5] Friedman, Daniel and Matthias Felliesen, The Little LISPer, Science Reseach Associates, [6] Friedman, Daniel and George Springer, Scheme and the Art of Programming, McGraw-Hill, [7] Hofstadter, Douglas, Lisp: Atoms and Lists, Metamagical Themas: Questing for the Essence of Mind and Pattern, Basic Books, 1985, pp [8] Hofstadter, Douglas, Lisp: Lists and Recursion, Metamagical Themas: Questing for the Essence of Mind and Pattern, Basic Books, 1985, pp [9] Hofstadter, Douglas, Lisp: Recursion and Generality, Metamagical Themas: Questing for the Essence of Mind and Pattern, Basic Books, 1985, pp

24 A Installation Installing XScheme: 1. Get a copy of the files xscheme.tar.z and install.scheme 2. Move those files to the directory in which the scheme files should be installed (/usr/local is good). A new subdirectory of the current directory, called xscheme, will be created to hold the XScheme files. 3. Type install.scheme 4. To run XScheme, type (dir)/xscheme/scheme, where (dir) is the directory in which XScheme was installed (such as /usr/local). You may find it helpful to add a line like the following to your.cshrc file: alias xscheme /usr/local/xscheme/scheme 5. You re done! 24

25 B Reference expression Section 3 Suppresses evaluation of expression. Equivalent to (quote expression). () Section 3 The empty list, synonymous with nil. (+ Nex 1 Nex 2 ) Section 6 Returns Nex 1 + Nex 2. Nex 1 and Nex 2 must be expressions with numerical values. (- Nex 1 Nex 2 ) Section 6 Returns Nex 1 Nex 2. Nex 1 and Nex 2 must be expressions with numerical values. (* Nex 1 Nex 2 ) Section 6 Returns Nex 1 Nex 2. Nex 1 and Nex 2 must be expressions with numerical values. (/ Nex 1 Nex 2 ) Section 6 Returns Nex 1 Nex 2. Nex 1 and Nex 2 must be expressions with numerical values. (= Nex 1 Nex 2 ) Section 4.1 Returns #t if Nex 1 and Nex 2 are numerically equal, () otherwise. Nex 1 and Nex 2 must be expressions with numerical values. (< Nex 1 Nex 2 ) Section 4.1 Returns #t if Nex 1 is numerically less than Nex 2, () otherwise. Nex 1 and Nex 2 must be expressions with numerical values. (> Nex 1 Nex 2 ) Section 4.1 Returns #t if Nex 1 is numerically greater than Nex 2, () otherwise. Nex 1 and Nex 2 must be expressions with numerical values. (<= Nex 1 Nex 2 ) Section 4.1 Returns #t if Nex 1 is numerically less than or equal to Nex 2, () otherwise. Nex 1 and Nex 2 must be expressions with numerical values. (<= Nex 1 Nex 2 ) Section 4.1 Returns #t if Nex 1 is numerically greater than or equal to Nex 2, () otherwise. Nex 1 and Nex 2 must be expressions with numerical values. (and predicate1... predicaten) Section 5 Evaluates its arguments from left to right, and returns nil as soon as one of them evaluates to nil. If none of the arguments evaluate to nil, it returns true. (append list1 list2) Section 3.2 Returns the concatenation of list1 and list2. 25

26 (atom? expression) Section 4 Returns #t if expression is an atom or the empty list, () otherwise. (car list) Section 3.2 Returns the head, or first element, of list. (cdr list) Section 3.2 Returns the tail of list, i.e., a copy of list with the first element removed. (cond (predicate1 consequent1)... ( predicaten consequentn)) Section 5 Evaluates its arguments from left to right; when predicatei returns true, the function consequenti is evaluated and its return value is returned as the value of the cond. An error occurs if none of the predicates returns true. (cons elem list) Section 3.2 Returns a new list the same as list, but with elem inserted as the head. (eq? expression1 expression2) Section 4 Returns true if expression1 and expression2 are the same object, false otherwise. (equal? expression1 expression2) Section 4 Returns true if expression1 and expression2 are equivalent objects; i.e., if they have the same list structure and their atoms are equivalent. (exit) Section 2 Exits XScheme and returns to the operating system. (if predicate then-part else-part) Section 5 A special case of cond; if predicate evaluates to true, the function then-part is evaluated and its return value is returned as the value of the if. Otherwise, the same is done with the function else-part. (lambda args body) Section 9 Defines a nameless function, witharguments args and functionbody body. args shouldbe a list(arg1 arg2... argn). (length expression) Section 3.2 Returns the length in number of elements of expression. The argument expression must evaluate to a list. (let ((var1 init1) (var2 init2)... (varn initn)) body) Section 8 Within the scope of body, binds var1 to init1, var2 to init2, etc. Returns the return value of body. (list arg1 arg2... argn) Section 3 Returns a list of its arguments, (arg1 arg2... argn). (list? expression) Section 4 Returns true if expression is a list, including the empty list, false otherwise. (load filename ) Section 2 Loads the text file specified by filename, just as though that text were entered from the keyboard. 26

27 nil Section 3 The empty list, synonymous with (). (not predicate) Section 4 Returns nil if predicate evaluates to true, otherwise returns true. (null? expression) Section 4 Returns true if expression is nil or (), false otherwise. (or predicate1... predicaten) Section 4 Evaluates its arguments from left to right, and returns true as soon as one of them evaluates to true. If none of the arguments evaluate to true, it returns nil. (quote expression) Section 3 Suppresses evaluation of expression. Equivalent to expression. (reset) Section 2 Resets any error condition and returns XScheme to the top level prompt. (reverse expression) Section 3.2 Returns a list made up of the elements in expression, in reverse order. The argument expression must evaluate to a list. (transcript-on filename ) Section 2 Begins a transcript, echoing all input to XScheme and output from XScheme to the file specified by filename. (transcript-off) Section 2 Ends the transcript, closing the file specified by the earlier transcript-on command. 27

28 Index, 5, 26 (), 5, 8, 26 *, 11, 26 +, 11, 26 -, 11, 26 /, 11, 26 <, 9, 26 <=, 9, 26 =, 9, 26 >, 9, 26 >=, 9 #t, 8 and, 9, 26 append, 7, 16, 17, 26 arguments variable number of, 13 arity, 5 assignment, 22 atom, 5 atom?, 8, 16, 27 begin, 19, 23 binding, 14 car, 6, 16, 17, 22, 27 cdr, 6, 16, 17, 22, 27 cond, 10, 16, 17, 27 cons, 6, 16, 17, 27 control, 10 define, 13, 14, 16, 17 else, 10 eq?, 8, 27 equal?, 8, 27 exit, 4, 27 expt, 12 factorial, 13 false, 8 flatten, 16 function, 5, 6, 13 functions as arguments, 15, 17 first-class, 15 if, 10, 27 installation, 25 lambda, 15, 17, 27 length, 7, 27 let, 14, 17, 27 list, 5, 6 empty, 5, 8, 23 head, 6 null, 5 tail, 6 list, 6, 27 list?, 8, 28 load, 4, 28 map, 15 math, 11 nil, 5, 8, 28 not, 8, 28 null?, 8, 16, 17, 28 numbers, 5 or, 9, 28 predicate, 8 numerical, 9 quicksort, 17 quote, 5, 28 quotient, 11 redirection, 19 referential transparency, 3 reset, 4, 28 reverse, 7, 28 s-expression, 5 side effects, 3, 20, 22 sqrt, 12 style guidelines, 22 28

29 transcript-off, 4, 28 transcript-on, 4, 28 transcripts, 4, 19 true, 8 variables global, 14 local, 14 naming, 22 write, 20 29

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

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

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

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

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

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

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

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

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

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

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

### LECTURE 16. Functional Programming

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

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

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

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

### Functional Programming. Pure Functional Programming

Functional Programming Pure Functional Programming Computation is largely performed by applying functions to values. The value of an expression depends only on the values of its sub-expressions (if any).

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

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

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

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

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

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

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

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

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

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

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

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

### Lisp. Versions of LISP

Lisp Versions of LISP Lisp is an old language with many variants Lisp is alive and well today Most modern versions are based on Common Lisp LispWorks is based on Common Lisp Scheme is one of the major

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

### ;; definition of function, fun, that adds 7 to the input (define fun (lambda (x) (+ x 7)))

Homework 1 Due 13 September Handout 2 CSC 131: Fall, 2006 6 September Reading 1. Read Mitchell, Chapter 3. 2. The Scheme Tutorial and the Scheme Quick Reference from the Links web page, as needed for the

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

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

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

### Chapter 15. Functional Programming Languages ISBN

Chapter 15 Functional Programming Languages ISBN 0-321-49362-1 Chapter 15 Topics Introduction Mathematical Functions Fundamentals of Functional Programming Languages The First Functional Programming Language:

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

### Homework 1. Reading. Problems. Handout 3 CSCI 334: Spring, 2012

Homework 1 Due 14 February Handout 3 CSCI 334: Spring, 2012 Reading 1. (Required) Mitchell, Chapter 3. 2. (As Needed) The Lisp Tutorial from the Links web page, as needed for the programming questions.

### CSCC24 Functional Programming Scheme Part 2

CSCC24 Functional Programming Scheme Part 2 Carolyn MacLeod 1 winter 2012 1 Based on slides from Anya Tafliovich, and with many thanks to Gerald Penn and Prabhakar Ragde. 1 The Spirit of Lisp-like Languages

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

### Functional programming in LISP

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

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

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

### Homework 1. Notes. What To Turn In. Unix Accounts. Reading. Handout 3 CSCI 334: Spring, 2017

Homework 1 Due 14 February Handout 3 CSCI 334: Spring, 2017 Notes This homework has three types of problems: Self Check: You are strongly encouraged to think about and work through these questions, but

### 4.2 Variations on a Scheme -- Lazy Evaluation

[Go to first, previous, next page; contents; index] 4.2 Variations on a Scheme -- Lazy Evaluation Now that we have an evaluator expressed as a Lisp program, we can experiment with alternative choices in

### CS251 Programming Languages Handout # 47 Prof. Lyn Turbak May 22, 2005 Wellesley College. Scheme

CS251 Programming Languages Handout # 47 Prof. Lyn Turbak May 22, 2005 Wellesley College 1 Scheme Overview Scheme Scheme is a block-structured, lexically-scoped, properly tail-recursive dialect of Lisp

### CS450: Structure of Higher Level Languages Spring 2018 Assignment 7 Due: Wednesday, April 18, 2018

CS450: Structure of Higher Level Languages Spring 2018 Assignment 7 Due: Wednesday, April 18, 2018 Taken from assignments by Profs. Carl Offner and Ethan Bolker Part 1 - Modifying The Metacircular Evaluator

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

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

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

### Repetition Through Recursion

Fundamentals of Computer Science I (CS151.02 2007S) Repetition Through Recursion Summary: In many algorithms, you want to do things again and again and again. For example, you might want to do something

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

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

### COP4020 Programming Assignment 1 - Spring 2011

COP4020 Programming Assignment 1 - Spring 2011 In this programming assignment we design and implement a small imperative programming language Micro-PL. To execute Mirco-PL code we translate the code to

### by the evening of Tuesday, Feb 6

Homework 1 Due 14 February Handout 6 CSCI 334: Spring 2018 Notes This homework has three types of problems: Self Check: You are strongly encouraged to think about and work through these questions, and

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

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

### INF4820: Algorithms for Artificial Intelligence and Natural Language Processing. Common Lisp Fundamentals

INF4820: Algorithms for Artificial Intelligence and Natural Language Processing Common Lisp Fundamentals Stephan Oepen & Murhaf Fares Language Technology Group (LTG) August 30, 2017 Last Week: What is

### Example Scheme Function: equal

ICOM 4036 Programming Languages Functional Programming Languages Mathematical Functions Fundamentals of Functional Programming Languages The First Functional Programming Language: LISP Introduction to

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

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

### Announcement. Overview. LISP: A Quick Overview. Outline of Writing and Running Lisp.

Overview Announcement Announcement Lisp Basics CMUCL to be available on sun.cs. You may use GNU Common List (GCL http://www.gnu.org/software/gcl/ which is available on most Linux platforms. There is also

### LISP. Everything in a computer is a string of binary digits, ones and zeros, which everyone calls bits.

LISP Everything in a computer is a string of binary digits, ones and zeros, which everyone calls bits. From one perspective, sequences of bits can be interpreted as a code for ordinary decimal digits,

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

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

### A Small Interpreted Language

A Small Interpreted Language What would you need to build a small computing language based on mathematical principles? The language should be simple, Turing equivalent (i.e.: it can compute anything that

### INF4820: Algorithms for Artificial Intelligence and Natural Language Processing. More Common Lisp

INF4820: Algorithms for Artificial Intelligence and Natural Language Processing More Common Lisp Stephan Oepen & Murhaf Fares Language Technology Group (LTG) September 6, 2017 Agenda 2 Previously Common

### CS 11 Haskell track: lecture 1

CS 11 Haskell track: lecture 1 This week: Introduction/motivation/pep talk Basics of Haskell Prerequisite Knowledge of basic functional programming e.g. Scheme, Ocaml, Erlang CS 1, CS 4 "permission of

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

### A Brief Introduction to Scheme (I)

A Brief Introduction to Scheme (I) Philip W. L. Fong pwlfong@cs.uregina.ca Department of Computer Science University of Regina Regina, Saskatchewan, Canada Scheme Scheme I p.1/44 Scheme: Feature Set A

### The PCAT Programming Language Reference Manual

The PCAT Programming Language Reference Manual Andrew Tolmach and Jingke Li Dept. of Computer Science Portland State University September 27, 1995 (revised October 15, 2002) 1 Introduction The PCAT language

### Interpreters and Tail Calls Fall 2017 Discussion 8: November 1, 2017 Solutions. 1 Calculator. calc> (+ 2 2) 4

CS 61A Interpreters and Tail Calls Fall 2017 Discussion 8: November 1, 2017 Solutions 1 Calculator We are beginning to dive into the realm of interpreting computer programs that is, writing programs that

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

### An Explicit Continuation Evaluator for Scheme

Massachusetts Institute of Technology Course Notes 2 6.844, Spring 05: Computability Theory of and with Scheme February 17 Prof. Albert R. Meyer revised March 3, 2005, 1265 minutes An Explicit Continuation

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

### Look at the outermost list first, evaluate each of its arguments, and use the results as arguments to the outermost operator.

LISP NOTES #1 LISP Acronymed from List Processing, or from Lots of Irritating Silly Parentheses ;) It was developed by John MacCarthy and his group in late 1950s. Starting LISP screen shortcut or by command

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

### Func%onal Programming in Scheme and Lisp

Func%onal Programming in Scheme and Lisp http://www.lisperati.com/landoflisp/ Overview In a func(onal programming language, func(ons are first class objects You can create them, put them in data structures,

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

### UNIVERSITY of CALIFORNIA at Berkeley Department of Electrical Engineering and Computer Sciences Computer Sciences Division

UNIVERSITY of CALIFORNIA at Berkeley Department of Electrical Engineering and Computer Sciences Computer Sciences Division CS61A Kurt Meinz Structure and Interpretation of Computer Programs Summer 2002

### CS 314 Principles of Programming Languages

CS 314 Principles of Programming Languages Lecture 15: Review and Functional Programming Zheng (Eddy) Zhang Rutgers University March 19, 2018 Class Information Midterm exam forum open in Sakai. HW4 and

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

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

### CSE413: Programming Languages and Implementation Racket structs Implementing languages with interpreters Implementing closures

CSE413: Programming Languages and Implementation Racket structs Implementing languages with interpreters Implementing closures Dan Grossman Fall 2014 Hi! I m not Hal J I love this stuff and have taught

### Functional Programming Lecture 1: Introduction

Functional Programming Lecture 1: Introduction Viliam Lisý Artificial Intelligence Center Department of Computer Science FEE, Czech Technical University in Prague viliam.lisy@fel.cvut.cz Acknowledgements

### Func%onal Programming in Scheme and Lisp

Func%onal Programming in Scheme and Lisp http://www.lisperati.com/landoflisp/ Overview In a func(onal programming language, func(ons are first class objects You can create them, put them in data structures,

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

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

### April 2 to April 4, 2018

MORE SCHEME COMPUTER SCIENCE MENTORS 61A April 2 to April 4, 2018 1 Scheme 1. What will Scheme output? Draw box-and-pointer diagrams to help determine this. (a) (cons (cons 1 nil) (cons 2 (cons (cons 3

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

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

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

### Pace University. Fundamental Concepts of CS121 1

Pace University Fundamental Concepts of CS121 1 Dr. Lixin Tao http://csis.pace.edu/~lixin Computer Science Department Pace University October 12, 2005 This document complements my tutorial Introduction

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

### Racket. CSE341: Programming Languages Lecture 14 Introduction to Racket. Getting started. Racket vs. Scheme. Example.

Racket Next 2+ weeks will use the Racket language (not ML) and the DrRacket programming environment (not emacs) Installation / basic usage instructions on course website CSE34: Programming Languages Lecture

### Chapter 15. Functional Programming Languages

Chapter 15 Functional Programming Languages Chapter 15 Topics Introduction Mathematical Functions Fundamentals of Functional Programming Languages The First Functional Programming Language: Lisp Introduction

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

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