1. SchemeCOP-40201 Introduction to Scheme

2. SchemeCOP-40202 Scheme Meta-language for coding interpreters –“ clean ” semantics Scheme = LISP + ALGOL –simple uniform syntax; symbols and lists –block structure; static scoping –statement : evaluated for its effect –expression : evaluated for its value Dynamic type checking –flexible but inefficient (rapid prototyping)

3. SchemeCOP-40203 Expressions Literals Variables Procedure calls Literals numerals(2), strings( “ abc ” ), boolean(#t), etc. Variables Identifier represents a variable. Variable reference denotes the value of its binding. x 5 ref

4. SchemeCOP-40204 Scheme Identifiers E.g., y, x5, +, two+two, zero?, etc (Illegal) 5x, y)2, ab c, etc Identifiers –reserved keywords –variables pre-defined functions/constants ordinary functions = procedures

5. SchemeCOP-40205 Procedure Call (application) (operator-expr operand-expr...) –prefix expression (proc/op arg1 arg2 arg3...) Order of evaluation of the sub-expressions is “ explicitly ” left unspecified by Scheme. cf. C is silent about it. cf. Java specifies a left to right processing. (+ x (p 2 3)) ((f 2 3) 5 6)

6. SchemeCOP-40206 Special Forms Definition (define ) Conditional (if ) (define false #f) (if (zero? 5) 0 #t)

7. SchemeCOP-40207 Data Types values, operations, canonical representation Type-checking static : compile-time : efficient dynamic : run-time : flexible –numbers: +, -, *, number?, = etc –booleans: #t, #f, boolean?, etc –strings: string?, string->list, etc

8. SchemeCOP-40208 Symbols Identifiers treated as primitive values. Manipulated at run-time. –Distinct from identifiers that name variables in the program text. –Distinct from strings (sequence of characters). Meta-programming quote symbol?

9. SchemeCOP-40209 Lists Ordered sequence of elements of arbitrary types (Heterogeneous) operations –car, cdr, cons, null?,... –list, append,... –first, second,..., ninth

10. SchemeCOP-402010 Pairs (cons ’a ’b) (cons ’a (cons ’b nil) ) a b ab nil ()

11. SchemeCOP-402011 Equivalence Test (eq? (cons 3 ()) (cons 3 ())) #f (define a (cons 3())) (define b (cons 3 ())) (eq? a b) #f (define c a) (eq? a c) #t

12. SchemeCOP-402012 Vectors Both records and arrays provide random access to components. However, records are heterogeneous, while arrays are homogenoeus. Vectors are heterogeneous structures that provide random access to components using a computable index.

13. SchemeCOP-402013 Constructors and accessors (define v (vector 1 (+ 1 2))) #(1 3) (vector-ref v 0) 1 (vector-length v) 2 Index is 0-based.

14. SchemeCOP-402014 Procedures In Scheme, procedures are first-class objects. That is, they may be passed to or returned from procedures or stored in a data structure. (if (procedure? 3) car cdr) # (procedure? append) #t

15. SchemeCOP-402015 ( (if (procedure? procedure?) car cdr) (cons cdr car)) ’(list append)) = ( (car (cons cdr car)) ’(list append)) = (cdr ’(list append)) = (append)

16. SchemeCOP-402016 Apply -function (apply cons ’( x (y z))) = (cons ’x ’(y z)) = (x y z) (apply f ’(a1 a2... an)) = (f ’a1 ’a2... ’an) (apply )

17. SchemeCOP-402017 (apply apply (list procedure? (list apply))) = (apply apply [ proc-fn [ apply-fn ] ] ) = (apply proc-fn [apply-fn] ) = #t

18. SchemeCOP-402018 Anonymous Fucntions (lambda ) E.g., ( (lambda (n) (+ n 2)) 5) = 7 Evaluate actual argument expressions Bind these values to formals Evaluate body expression (static scoping)

19. SchemeCOP-402019 Variable Arity Procedures (+ 1 2 3) (append ’(1 (p q)) () ’(a b c)) (list 1 2 3 4 5) (lambda ) is bound to the list of actual argument values supplied in a call.

20. SchemeCOP-402020 (define mul (lambda x (if (null? x) 1 (* (car x) (apply mul (cdr x)) ) )) ; 1 is identity w.r.t * ) ; assuming * is binary (mul 1 (+ 2 3) 5)

21. SchemeCOP-402021 Binding constructs in Scheme define binds value to a name. -function application binds formal parameters to actual argument values. let -constructs introduces local bindings –let –let* –letrec

22. SchemeCOP-402022 let -construct ( let ( (var1 exp1) … (varn expn)) exp ) exp1 to expn are evaluated in the surrounding context. var1,…,varn are visible only in exp. >(let ( (x 2) (y 7) ) y) >7

23. SchemeCOP-402023 >(let ( (x y ) (y 7) ) y) >*error* “ y ” undefined >(define y 5) >(let ( (x y ) (y 7) ) y) >7 >(let ( (x y ) (y 7) ) x) >5 >(let ( (y 7) (x y ) ) x) >5 (not 7)

24. SchemeCOP-402024 >(define y 5) >(let ( (y 7) (x y ) ) x) >5 >(let ( (y 7) ) (let ( (x y ) ) x) ) >7 >(let* ( (y 7) (x y) ) x) >7 let* abbreviates nested- let s. Recursive and mutually recursive functions cannot be defined using let and let*.

25. SchemeCOP-402025 letrec -construct ( letrec ( (var1 exp1) … (varn expn)) exp ) var1,…,varn are visible in exp1 to expn in addition to exp. > (letrec ( (x (lambda() y) (y (lambda() x) ) x )

26. SchemeCOP-402026 letrec -construct ( ) >(letrec ( (f (lambda(n) (if (zero? n) 1 (f (- 1 n)) )) ) ) (f 5) ) >1 >(letrec ( ( f (lambda () g) ) ( g 2 ) ) ( f ) ) >2

27. SchemeCOP-402027 boolean connectives (or test1 test2 … testn) (and test1 test2 … testn) or and and are not Scheme procedures. They use short circuit evaluation rather than traditional call-by-value.

28. SchemeCOP-402028 Branching constructs (cond (test1 exp1) (test2 exp2) … (testn expn) (else exp) ) (case key ( keylist1 exp1) ( keylist2 exp2) … ( keylistn expn) (else exp) )