Introduction to Scheme L2Scm
Language Syntax(BNF) Semantics Pragmatics Data Control Abstract Data Types Denotational AxiomaticOperational (interpreter-based) Attribute Grammar Framework L2Scm
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) L2Scm
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 L2Scm
Expressible vs Denotable values • Booleans are expressible in (early) FORTRAN, but not denotable. • Functions are denotable in C/Pascal, but are not expressible. • In (functional subset of) Scheme, both values spaces are identical. • In (full) Scheme, variable references (pointers) are denotable but not expressible. L2Scm
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 L2Scm
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) L2Scm
Special Forms • Definition • (define <var> <expr>) • Conditional • (if <test> <then> <else>) (define false #f) (if (zero? 5) 0 #t) L2Scm
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 L2Scm
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? L2Scm
Lists • Ordered sequence of elements of arbitrary types (Heterogeneous) • operations • car, cdr, cons, null?, ... • list, append, ... • first, second, ..., ninth L2Scm
Pairs (cons ’a ’b) (cons ’a (cons ’b nil) ) b a nil () a b L2Scm
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 L2Scm
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. L2Scm
Constructors and accessors (define v (vector 1 (+ 1 2))) #(1 3) (vector-ref v 0) 1 (vector-length v) 2 • Index is 0-based. L2Scm
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> (procedure? append) #t L2Scm
( (if (procedure? procedure?) car cdr) (cons cdr car)) ’(list append)) = ( (car (cons cdr car)) ’(list append)) = (cdr ’(list append)) = (append) L2Scm
Apply-function (apply cons ’( x (y z))) = (cons ’x ’(y z)) = (x y z) (apply f ’(a1 a2 ... an)) = (f ’a1 ’a2 ... ’an) (apply <func> <list-of-args>) L2Scm
(apply apply (list procedure? (list apply))) = (apply apply [ proc-fn [ apply-fn ] ] ) = (apply proc-fn [apply-fn] ) = #t L2Scm
Anonymous Fucntions (lambda <formals> <body-expr>) E.g., ( (lambda (n) (+ n 2)) 5) = 7 • Evaluate actual argument expressions • Bind these values to formals • Evaluate body expression (static scoping) L2Scm
Variable Arity Procedures (+ 1 2 3) (append ’(1 (p q)) () ’(a b c)) (list 1 2 3 4 5) (lambda <formal> <body>) • <formal> is bound to the list of actual argument values supplied in a call. L2Scm
(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) L2Scm
Binding constructs in Scheme • define • binds value to a name. • l-function application • binds formal parameters to actual argument values. • let-constructs • introduces local bindings • let • let* • letrec L2Scm
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 L2Scm
(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) L2Scm
(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-lets. • Recursive and mutually recursive functions cannot be defined using let and let*. L2Scm
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 ) L2Scm
letrec-construct • (letrec ( (f (lambda(n) (if (zero? n) 1 (f (- 1 n)) )) ) ) (f 5) ) • 1 • (letrec ( ( f (lambda () g) ) ( g 2) ) ( f ) ) • 2 L2Scm
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. L2Scm
(cond (test1 exp1) (test2 exp2) … (testn expn) (else exp) ) (case key (keylist1 exp1) (keylist2 exp2) … (keylistn expn) (else exp) ) Branching constructs L2Scm
