1. Scheme : variant of LISP
LISP : John McCarthy (1958)
Scheme : Steele and Sussman (1973)
Those who do not learn from history are doomed to repeat it. - George Santayana
C/Pascal : Procedural / Imperative
Java/C++: Object-oriented style
Scheme/LISP : Functional style
General purpose languages vs scripting languages
cs3180(Prasad)
L12Scm

2. Scheme (now called Racket)
Scheme = LISP + ALGOL
symbolic list manipulation
block structure; static scoping
Symbolic Computation
Translation
Parsers, Compilers, Interpreters.
Querying / Reasoning
Natural language understanding systems
Database querying
Searching / Question-Answering
Reasoners:
make explicit information implicit
in the facts and rules
First-order logic deduction,
common-sense reasoning
cs3180(Prasad)
L12Scm

3. “Striking” Features Simple and uniform syntax
Support for convenient list processing
(Automatic) Garbage Collection
Environment for Rapid Prototyping
Intrinsically generic functions
Dynamic typing (flexible but inefficient)
Compositionality through extensive use of lists. (minimizing impedance mismatch)
Trivial syntax, minimal punctuations --- useful for meta-programming
Code a solution before getting an optimal one : rapid prototyping
no extra syntax for generics : other languages overspecific
reliability not sacrificed. cf. static typing, OOPL’s polymorphic type system
cs3180(Prasad)
L12Scm

4. Expressions Literals Variables Procedure calls Literals Variables
numerals(2), strings( “abc” ), boolean( #t ), etc.
Variables
Identifier represents a variable. Variable reference denotes the value of its binding. x
Cf. Java reference types
ref 5
cs3180(Prasad)
L12Scm

5. Scheme Identifiers E.g., y, x5, +, two+two,
zero?, list->string, etc
(Illegal) 5x, y)2, ab c, etc
Identifiers
reserved keywords
variables
pre-defined functions/constants
ordinary
functions = procedures
Not case sensitive
In Java : two+two counts as 3 tokens
(two, +, two) Blanks mandatory.
ABC= AbC = abc = abC = …
In Scheme: two+two is just one token.
cs3180(Prasad)
L12Scm

6. Procedure Call (application)
(operator-expr operand-expr ...)
prefix expression (proc/op arg1 arg2 arg3 ...)
(+ x (p ))
Function value
( (f 2 3) )
f is Higher-order function
The operator-expression must yield a function value compatible with the operand expressions.
(f 2 3) must return a binary function on integers.
Higher-order functions.
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.
cs3180(Prasad)
L12Scm

7. Simple Scheme Expressions
(+  12  13)   
= 25
(/  12  14)   
= 6/7
( i  i )
= i
(* i   0+i )
= ( i)
(< )
= #t
(positive? 25)
= #t
(negative? (- 1 0))
= #f
(expt 2 10)
= 1024
(sqrt 144)
= 12
(string->number “12” 8)
= 10
(string->number “AB” 16)
= 171
(string->number “ABC”)
= #f
10* = 171
cs3180(Prasad)
L12Scm

8. Scheme Evaluation Rule (REPL)
Expression
blank separated, parentheses delimited,
nested list structure
Evaluation
Evaluate each element of the outerlist recursively.
Apply the result of the operator expression (of function type) to the results of zero or more operand expressions.
The syntax of a program is well-matched with the basic data structure the programs manipulate to facilitate META-PROGRAMMING. “program-manipulating programs”
REPL: Read Eval Print Loop
cs3180(Prasad)
L12Scm

9. (+ (* 2 3) (- 4 (/ 6 3) )) (+ (* 2 3) (- 4 2) ) (+ 6 2) 8
Simple Example
(+ (* 2 3) (- 4 (/ 6 3) )) (+ (* 2 3) (- 4 2) ) (+ 6 2) 8
cs3180(Prasad)
L12Scm

10. Lists Ordered sequence of elements of arbitrary type (Heterogeneous)
Empty List : ()
3-element list : (a b 3)
Nested list : (1 (2.3 x) 4)
Sets vs lists
Duplication matters: (a) =/= (a a)
Order matters: (a b) =/= (b a)
Nesting-level matters: ( a ) =/= ( (a) )
cs3180(Prasad)
L12Scm

11. Key Point
Syntax of Scheme programs has been deliberately designed to match syntax of lists -- its most prominent data structure
Important consequence:
Supports meta-programming
Enables program manipulating programs
cs3180(Prasad)
L12Scm

12. Special Forms Definition Conditional (define <var> <expr>)
E.g., (define false #f)
Conditional
(if <test> <then> <else>)
E.g., (if (number? 5)
(zero? “a”)
(/ 10 0) )
define takes the first argument as is.
Need: do not evaluate all the arguments conditional evaluates either the then-expr or the else-expr but not both.
(if ’() ’1 ’2) => 1
(if (symbol? 'a) (zero? 5) (/ 1 0)) => #f
cs3180(Prasad)
L12Scm

13. Symbols Identifiers treated as primitive values.
Distinct from identifiers that name variables in program text.
Distinct from strings (sequence of characters).
Some meta-programming primitives
quote
symbol?
cs3180(Prasad)
L12Scm

14. Symbolic Data : quote function
“say your name aloud”
“say ‘your name’ aloud”
variable vs symbolic data (to be taken literally)
(define x 2)
x = 2
(quote x) = x
’x = x
(+ 3 6) = 9
’(+ 3 6) > list value
cs3180(Prasad)
L12Scm

15. Pairs (cons ’a ’b) (cons ’a (cons ’b ’()) ) Printed as: (a . b) a b
cs3180(Prasad)
L12Scm

16. (cont’d) (cons ’a (cons ’a (cons ’b ’()))) Printed as: (a a b) a () a
cs3180(Prasad)
L12Scm

17. List Functions Operations Expressions car, cdr, cons, null?, ...
list, append, ...
cadr, caddr, caaar, ...
Expressions
( length (quote (quote a)) )
( length ’’’a ) = 2
( length ’’’’’’’quote )
(cadar X) = (car (cdr (car X)))
The first implementation of LISP was on an IBM 704 by Steve Russell, who read McCarthy's paper and coded the eval function he described in machine code. The familiar (but puzzling to newcomers) names CAR and CDR used in LISP to describe the head element of a list and its tail, evolved from two IBM 704 assembly language commands: Contents of Address Register and Contents of Decrement Register, each of which returned the contents of a 15-bit register corresponding to segments of a 36-bit IBM 704 instruction word.
cs3180(Prasad)
L12Scm

18. { allocate storage for the list and initialize xl}
(define xl ’(a b c))
{ allocate storage for the list and initialize xl}
car, first : list -> element
(car xl) = a
cdr : list -> list
(cdr xl) = (b c)
{ non-destructive }
cons : element x list -> list
(cons ’a ’(b c)) = (a b c)
car: contents of address register
cdr : contents of decrement register
cons: construct
IBM 704 m/c implementation
cs3180(Prasad)
L12Scm

19. (cons (car xl) (cdr xl)) = xl
For all non-empty lists xl:
(cons (car xl) (cdr xl)) = xl
For all x and lists xl:
(car (cons x xl)) = x
(cdr (cons x xl)) = xl
car : first element of the outermost list.
cdr : list that remains after removing car.
(cons ’() ’()) = ??
(cons ’() ’()) = (())
Wrong alternatives:
() (()())
cs3180(Prasad)
L12Scm

20. null? : list -> boolean
(null? ’()) = #t
(null? ’(a)) = #f
(null? 25) = #f
list : elements x ... -> list
(list ’a ’(a) ’ab) = (a (a) ab)
append : list x ...-> list
(append ’() (list ’a) ’(0)) = (a 0)
{ variable arity functions }
cs3180(Prasad)
L12Scm

21. Role of parentheses Program Data Extra call to interpreter
(list ’append)
= (append)
(list (append))
= (())
(list (append)
(append)) = ?
= (()())
Data
Extra level of nesting
(car ’(a))
= a
(car ’((a)))
= (a)
(list append
append) = ?
cs3180(Prasad)
L12Scm

22. Equivalence Test (define a (cons 3 ’())) (define b (cons 3 ’()))
(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
cs3180(Prasad)
L12Scm

23. Equivalent Scheme Expressions
( (car (list append list))
(cons ’a ’()) ’(1 2 3) )
= ( append ’(a) ’(1 2 3) )
= ’(a 1 2 3)
( (cdr (cons car cdr))
(cons ’car ’cdr) )
= ( cdr ’(car . cdr) )
= ’cdr
cs3180(Prasad)
L12Scm