* Scheme Introduction ** advertisment for Scheme ** History * Built-in types of Scheme ** Fundamental classifications *** atoms: string of characters beginning with letter, digit, or char *** lists: sequence of S-expressions enclosed by parentheses *** S-expression: atom, or list ** symbol ---------------------- (quote a) ;Value: a (symbol? (quote a)) ;Value: #T (eq? (quote a) (quote a)) ;Value: #T (eq? (quote a) (quote b)) ;Value: () (eq? 'a 'A) ; case does not matter for symbols ;Value: #T (eq? '() #f) ;Value: #T ---------------------- *** quotation suppresses evaluation ---------------------- (define a-symbol 3) a-symbol ;Value: 3 'a-symbol ;Value: a-symbol ''a-symbol ;Value: 'a-symbol ; not needed for "self-evaluating" atoms: numbers, strings, booleans 3 ;Value: 3 (quote 3) ;Value: 3 ---------------------- ** Boolean ---------------------- ; false is #f, which in C-scheme is represented by () ; true is #t, and is represented by everything that is not eq? to #f #f ;Value: () #t ;Value: #T (not #t) ;Value: () (not #f) ;Value: #T ---------------------- ---------------------- ; suppose value of e1 is val-e1 and value of e2 is val-e2 (define e1 'val-e1) (define e2 'val-e2) (if #t e1 e2) ;Value: val-e1 (if #f e1 e2) ;Value: val-e2 (and e1 e2) =def= (let ((ve1 e1)) (if (not (null? ve1)) e2 ve1)) (or e1 e2) =def= (let ((ve1 e1)) (if (null? ve1) e2 ve1)) ---------------------- *** Notation: conditional statement ---------------------- (cond (#t e1)) ;Value: val-e1 (cond (#f e1)) ;Value: () (cond (e11 e12) ... (en1 en2)) =def= (if e11 e12 (cond (e21 e22) ... (en1 en2))) (cond (e1 e2) ... (else en2)) =def= (cond (e1 e2) ... (#t en2)) ---------------------- ** lists ---------------------- ; suppose value of x is x and value of y is y (define x 'x) (define y 'y) ; suppose l is the list (a b c), l2 is list (d e) (define l '(a b c)) (define l2 '((d) (e))) (cons x '()) ;Value: (x) (car (cons x l)) ;Value: x (cdr (cons x l)) ;Value: (a b c) (pair? (cons x l)) ;Value: #T (pair? '()) ;Value: () (null? '()) ;Value: #T (null? (cons x l)) ;Value: () (equal? '() '()) ;Value: #T (equal? (cons x l) (cons y l2)) =def= (and (eqv? x y) (equal? l l2)) ;Value: () (list 'a 'b 'c) =def= (cons 'a (cons 'b (cons 'c nil))) ;Value: (a b c) ---------------------- *** Notation: quotes and quasi-quotes ------------------------ '() ;Value: () '(a b c) =def= (quote (a b c)) ;Value: (A B C) `(e1 e2) =def= (quasiquote (e1 e2)) ;Value: (E1 E2) `(,e1 ,e2) =def= (quasiquote ((unquote e1) (unquote e2))) ;Value: (val-e1 val-e2) `(,@l ,l) =def= (quasiquote ((unquote-splicing l) (unquote l))) ;Value: (A B C (A B C)) (caar l2) =def= (car (car l2)) ;Value: D (cadr l2) =def= (car (cdr l2)) ;Value: E ------------------------ *** Dotted pairs (cons cells, trees): *** Examples **** normal recursion on lists, ask if null? first -------- (define (length-recursive x) (if (null? x) 0 (+ 1 (length-recursive (cdr x))))) --------- **** tail recursive: last call in function is recursive, --------- (define (length-tail-recursive x) (define (length-iter a count) (cond ((null? a) count) (else (length-iter (cdr a) (+ 1 count))))) (length-iter x 0)) --------- **** additional operations on lists ***** append -------- (define (append-recursive x y) (cond ((null? x) y) (else (cons (car x) (append-recursive (cdr x) y))))) --------- ***** reverse --------- (define (reverse-recursive x) (cond ((null? x) x) (else (append (reverse-recursive (cdr x)) (list (car x)))))) (define (reverse-tail-recursive x) (define (reverse-iter y res) (cond ((null? y) res) (else (reverse-iter (cdr y) (cons (car y) res))))) (reverse-iter x '())) ---------- *** Lists can represent other data structures **** arrays -easy (although built-in to most dialects) **** variants - tag (in car) + object (in rest of list) **** records - association lists (or property lists) ***** Association lists (records) ----------- (define (acons key datum alist) (cons (cons key datum) alist)) (define (assoc key alist) (cond ((null? alist) nil) ((and (pair? (car alist)) (equal? key (caar alist))) (car alist)) (else (assoc key (cdr alist))))) ; tail recursive ----------- *** Other important type: procedures, will be discussed later ** Eq? vs. eqv? vs. equal? *** eq? compares symbols, booleans, and lists for object identity *** eqv? compares as eq? for symbols, booleans, lists, *** equal? compares structure, using eqv? as basis for comparing atoms. * Name bindings statically scoped ** define ---------- (define (my-member x L) (cond ((null? L) '()) ((eq? x (car L)) L) (else (my-member x (cdr L))))) ---------- ** let, simultaneous local bindings ** let*, sequential local bindings ** set! *** Binding vs. assignment ** initial environment