Lisp Introduction. Dr. Neil T. Dantam. Spring CSCI-498/598 RPM, Colorado School of Mines. Dantam (Mines CSCI, RPM) Lisp Spring / 88

Transcription

1 Lisp Introduction Dr. Neil T. Dantam CSCI-498/598 RPM, Colorado School of Mines Spring 28 Dantam (Mines CSCI, RPM) Lisp Spring 28 / 88

2 Outline Lisp Common Lisp by Example Implementation Details Typing Memory Management Functional Programming Closures Recursion Functional Operators Programming Environment Appendix Dantam (Mines CSCI, RPM) Lisp Spring 28 2 / 88

3 Lisp Outline Lisp Common Lisp by Example Implementation Details Typing Memory Management Functional Programming Closures Recursion Functional Operators Programming Environment Appendix Dantam (Mines CSCI, RPM) Lisp Spring 28 3 / 88

4 Lisp What is Lisp? Definition: Lisp A family of programming languages that are based on s-expressions. Dantam (Mines CSCI, RPM) Lisp Spring 28 4 / 88

5 Lisp Major Lisp Dialects Scheme Common Lisp Clojure IEEE Standard Simple and clean ANSI Standard Featureful Good compilers Efficient C interop. JVM-based Good Java interop. CLR and Javascript also Concurrency features Dantam (Mines CSCI, RPM) Lisp Spring 28 5 / 88

6 Common Lisp by Example Outline Lisp Common Lisp by Example Implementation Details Typing Memory Management Functional Programming Closures Recursion Functional Operators Programming Environment Appendix Dantam (Mines CSCI, RPM) Lisp Spring 28 6 / 88

7 Common Lisp by Example Booleans and Equality Math Lisp Notes False nil equivalent to the empty list () True t or any non-nil value a (not a) a = b (= a b) numerical comparison a = b (eq a b) same object a = b (eql a b) same object, same number and type, or same character a = b (equal a b) eql objects, or lists/arrays with equal elements a = b (equalp a b) = numbers, or same character (case-insensitive), or recursively-equalp cons cells, arrays, structures, hash tables a b (not (= a b)) similarly for other equality functions Dantam (Mines CSCI, RPM) Lisp Spring 28 7 / 88

8 Common Lisp by Example Example: Lisp Equality Operators (= ) t (eq ) t (= (eq (eql integer {}}{ integer {}}{ (equal integer {}}{ (equalp float {}}{. ) t float {}}{. ) nil integer {}}{ float {}}{. ) nil integer {}}{ float {}}{. ) nil float {}}{. ) t (= "a" "a") error (eq "a" "a") nil (eql "a" "a") nil (equal "a" "a") t (equal "a" "A") nil (equalp "a" "A") t (not t) nil (not nil) t (not "a") nil Dantam (Mines CSCI, RPM) Lisp Spring 28 8 / 88

9 Common Lisp by Example Exercise: Lisp Equality Operators (not ) (not ) (eq (list a b ) (list a b )) (equal (list a b ) (list a b )) (eq t (not nil)) (eq t ) (eq nil (not )) (eq (list a b ) (list a B )) (equal (list a b ) (list a B )) (eq nil (not "a")) (equalp (list a b ) (list a B )) Dantam (Mines CSCI, RPM) Lisp Spring 28 9 / 88

10 Common Lisp by Example Inequality Math Lisp a < b (< a b) a b (<= a b) a > b (> a b) a b (>= a b) Dantam (Mines CSCI, RPM) Lisp Spring 28 / 88

11 Common Lisp by Example Function Definition Procedure increment(n) return n + ; function name {}}{ (defun increment (+ n ) ) }{{} result function arguments {}}{ (n) Dantam (Mines CSCI, RPM) Lisp Spring 28 / 88

12 Common Lisp by Example Exercise: Function Definition sinc θ = sin θ θ Pseudocode Common Lisp Procedure sinc(θ) return sin(θ)/θ; Dantam (Mines CSCI, RPM) Lisp Spring 28 2 / 88

13 Common Lisp by Example Limit of sinc θ sin θ lim θ θ l Hôpital s rule lim θ d dθ sin θ cos θ d dθ θ lim θ Dantam (Mines CSCI, RPM) Lisp Spring 28 3 / 88

14 Common Lisp by Example Conditional IF Procedure even?(n) if = mod(n, 2) then 2 return true; 3 else 4 return false; (defun even? (n) test {}}{ (if (= (mod n 2)) then clause {}}{ t )) nil }{{} else clause Dantam (Mines CSCI, RPM) Lisp Spring 28 4 / 88

15 Common Lisp by Example Exercise: Conditionals IF sinc(θ) = { if θ = sin θ θ if θ Pseudocode Common Lisp Procedure sinc(θ) if = θ then 2 return ; 3 else 4 return sin(θ)/θ; Dantam (Mines CSCI, RPM) Lisp Spring 28 5 / 88

16 Common Lisp by Example Taylor Series Represent function f (x) as infinite sum of derivatives around point a: f (x) = f (a) + f (a) (! = n= (x a) + f (a) 2! ) f (n) (a) (x a) n n! (x a) + f (a) (x a) ! Polynomial approximation of functions Dantam (Mines CSCI, RPM) Lisp Spring 28 6 / 88

17 Common Lisp by Example Sinc Taylor Series 2 sin θ θ = θ2 6 + θ4 2 θ θ θ n = n = n = 2 n = 4 n = 6 n = 8 n = Dantam (Mines CSCI, RPM) Lisp Spring 28 7 / 88

18 Common Lisp by Example Conditional COND Procedure sign(n) if n > then 2 return ; 3 else if n < then 4 return ; 5 else 6 return ; (defun sign (n) test {}}{ (cond ((> n ) test {}}{ ((< n ) test {}}{ ( t result {}}{ ) result {}}{ ) result {}}{ ))) Dantam (Mines CSCI, RPM) Lisp Spring 28 8 / 88

19 Common Lisp by Example Exercise: Conditionals COND Pseudocode sin θ θ = θ2 6 + θ Common Lisp Procedure sinc(θ) if = θ then return ; 2 else if θ 2 <. then 3 return θ 2 /6 + θ 4 /2; 4 else return sin(θ)/θ ; Dantam (Mines CSCI, RPM) Lisp Spring 28 9 / 88

20 Common Lisp by Example Example: Factorial n! = { if n = n (n )! if n Pseudocode Common Lisp Procedure factorial(x) if = x then 2 return ; 3 else 4 return x factorial(x ); ( defun f a c t o r i a l ( n ) ( i f (= n ) ( n ( f a c t o r i a l ( n ) ) ) ) ) Dantam (Mines CSCI, RPM) Lisp Spring 28 2 / 88

21 Common Lisp by Example Exercise: Fibonacci Sequence (,, 2, 3, 5, 8, 3, 2, 34, 55,...) if n = fib(n) = if n = fib(n ) + fib(n 2) if n 2 Dantam (Mines CSCI, RPM) Lisp Spring 28 2 / 88

22 Common Lisp by Example Exercise: Fibonacci Sequence continued Pseudocode Common Lisp Dantam (Mines CSCI, RPM) Lisp Spring / 88

23 Common Lisp by Example Numerical Integration Runge-Kutta Methods Given: Find: x(t n ) d Derivative: x(t) = f (x, t) dt Initial time: t Final time: t n Initial value: x(t ) Solution: Follow derivative along discrete time intervals t from t to t n Dantam (Mines CSCI, RPM) Lisp Spring / 88

24 Common Lisp by Example Example: Runge-Kutta (Euler s Method).2.8 x i+ x i + t f (x i, t i ) Dantam (Mines CSCI, RPM) Lisp Spring / 88

25 Common Lisp by Example Example: Runge-Kutta (Euler s Method) continued x i+ x i + t f (x i, t i ) Procedure euler-step(dx, dt, x ) return x + dx dt; ( defun e u l e r s t e p ( dx dt x ) (+ x ( dx dt ) ) ) Dantam (Mines CSCI, RPM) Lisp Spring / 88

26 Common Lisp by Example Example: Runge-Kutta 2 (Midpoint Method) x i+ x i + t ẋ(t i + t 2 {}} ) { f (x i + t 2 f (x i, t i ), t + t 2 ) Procedure rk2-mid(f, t, x, dt) function ks(c, k) is 2 x euler-step(k, c dt, x ); 3 return f (x, t + c dt); 4 k f (x, t ); 5 k ks(/2, k ); 6 return x + dt k ; ( defun rk2 mid step ( f t x dt ) ( l a b e l s ( ( ks ( c k ) ( f u n c a l l f ( e u l e r s t e p k ( c dt ) x ) (+ t ( c dt ) ) ) ) ) ( l e t ( ( k ( f u n c a l l f x t ) ) ( k ( ks (/ 2) k ) ) ) (+ x ( dt k ) ) ) ) ) Dantam (Mines CSCI, RPM) Lisp Spring / 88

27 Common Lisp by Example Exercise: Runge-Kutta 2 (Heun s Method) ẋ(t x i+ x i + t i ) ẋ(t+ t) {}}{ 2 f (x i, t i ) + t {}}{ 2 f (x i + ( t)f (x i, t i ), t + t) x i + t 2 k + t 2 k Dantam (Mines CSCI, RPM) Lisp Spring / 88

28 Common Lisp by Example Exercise: Runge-Kutta 2 (Heun s Method) continued Procedure rk2-heun(f, t, x, dt) function ks(c, k) is 2 x euler-step(k, c dt, x ); 3 return f (x, t + c dt); 4 k f (x, t ); 5 k ks(, k ); 6 return x + dt/2 (k + k ); Dantam (Mines CSCI, RPM) Lisp Spring / 88

29 Common Lisp by Example Exercise: Runge-Kutta 4 where: k = f (x i, t i ) x i+ x i + t 6 ẋ(t i ) {}}{ k + t 3 ẋ(t i + t 2 ) {}}{ k (start) k = f (x i + t 2 k, t i + t 2 ) (midpoint) k 2 = f (x i + t 2 k, t i + t 2 ) (midpoint) k 3 = f (x i + ( t)k 2, t i + t) (end) + t 3 ẋ(t i + t 2 ) {}}{ k 2 + t 6 ẋ(t i + t) {}}{ k 3 Dantam (Mines CSCI, RPM) Lisp Spring / 88

30 Common Lisp by Example Exercise: Runge-Kutta 4 continued Dantam (Mines CSCI, RPM) Lisp Spring 28 3 / 88

31 Common Lisp by Example Euler Integration Procedure int-euler(f, t, t n, dt, x ) if t t n then // Base Case 2 return x ; 3 else // Recursive Case 4 dx f (x, t ); 5 x euler-step(dx, dt, x ); 6 return int-euler(f, t + dt, t n, dt, x); ( defun i n t e u l e r ( f t t dt x ) ( i f (>= t t ) x ( l e t ( ( dx ( f u n c a l l f x t ) ) ( x ( e u l e r s t e p dx dt x ) ) ) ( i n t e u l e r f (+ t dt ) t dt x ) ) ) ) Dantam (Mines CSCI, RPM) Lisp Spring 28 3 / 88

32 Common Lisp by Example RK-2 Integration Procedure int-rk2(f, t, t n, dt, x ) if t t n then // Base Case 2 return x ; 3 else // Recursive Case 4 x rk2-heun(f, t, x, dt); 5 return int-rk2(f, t + dt, t n, dt, x); ( defun int rk2 ( f t t dt x ) ( i f (>= t t ) x ( int rk2 f (+ t dt ) t dt ( rk2 heun f t x dt ) ) ) ) Dantam (Mines CSCI, RPM) Lisp Spring / 88

33 Common Lisp by Example Multi-method RK Integration Procedure integrate(s, f, t, t n, dt, x ) Dantam (Mines CSCI, RPM) Lisp Spring / 88

34 Implementation Details Outline Lisp Common Lisp by Example Implementation Details Typing Memory Management Functional Programming Closures Recursion Functional Operators Programming Environment Appendix Dantam (Mines CSCI, RPM) Lisp Spring / 88

35 Implementation Details Typing Data Types Definition: Data type A classification of data/objects based on how the data/object is intended to or able to be use. The set of values a variable may take. Examples int float List String Structures: int string float 4 Dantam (Mines CSCI, RPM) Lisp Spring / 88

36 Implementation Details Typing Data Type Systems Type Checking Static: Check types at compile time (statically) Dynamic: Check types at run time (dynamically) Type Enforcement Strong: Object types are strictly enforced Weak: Objects can be treated as different types (casting, type punning ) Dantam (Mines CSCI, RPM) Lisp Spring / 88

37 Implementation Details Typing Comparison of Language Type Systems C++ Static Java, ML/Haskell C Weak Common Lisp Strong Assembly, Shell Perl Dynamic Python Dantam (Mines CSCI, RPM) Lisp Spring / 88

38 Implementation Details Typing Machine Words Representing Data x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x 3 word 3 unsigned 42 x2a 3 signed -42 xffffffd6 3 float 42. = x4228 Dantam (Mines CSCI, RPM) Lisp Spring / 88

39 Implementation Details Typing Words and Types word 3 xc49fd? (signed) xc49fd? (unsigned) xc49fd? (float) xc49fd? valid pointer Dantam (Mines CSCI, RPM) Lisp Spring / 88

40 Implementation Details Typing Type Tags Data Tag 3 SBCL Tags (32-bit) Type Tag Even Fixnum b Odd Fixnum b Instance Pointer b List Pointer b Function Pointer b data {}}{ x892fa tag {}}{ b even fixnum (x892fa >> 2) Dantam (Mines CSCI, RPM) Lisp Spring 28 4 / 88

41 Implementation Details Typing Example: Tagged Storage 64-bit SBCL: Fixnum: (eq ) t 64 bit 64 bit 64 bit 64 bit 64 bit 64 bit Single Float: (eq.s.s) t eq NIL Double Float: (eq.d.d) nil eq.. NIL eq.d.d NIL Dantam (Mines CSCI, RPM) Lisp Spring 28 4 / 88

42 Implementation Details Typing Example: SBCL Arrays ( l e t ( ( a ( make array 5 : element type d o u b l e f l o a t ) ) ) ; ;.... ) data 64 bit 64 bit 64 bit 64 bit 64 bit.d.d.d.d.d A type descriptor (SIMPLE-ARRAY DOUBLE-FLOAT (5)) Dantam (Mines CSCI, RPM) Lisp Spring / 88

43 Implementation Details Memory Management Manual Memory Management malloc(n) free(ptr). Find a free block of at least n bytes 2. If no such block, get more memory from the OS 3. Return pointer to the block. Add block back to the free list(s) Dantam (Mines CSCI, RPM) Lisp Spring / 88

44 Implementation Details Memory Management Garbage Collection CPU registers r r... Roots Global Variables h h Heap h 4 h 6 r k r k h 2 h 3 h 5 h 7 Local Variables Stack Dantam (Mines CSCI, RPM) Lisp Spring / 88

45 Functional Programming Outline Lisp Common Lisp by Example Implementation Details Typing Memory Management Functional Programming Closures Recursion Functional Operators Programming Environment Appendix Dantam (Mines CSCI, RPM) Lisp Spring / 88

46 Functional Programming Functional Programming Features Functions are first class object Prefer immutable state Garbage collection Dantam (Mines CSCI, RPM) Lisp Spring / 88

47 Functional Programming Closures Closure Definition (Closure) A function and an associated set of variable definitions. From closed expression. / D e f i n i t i o n / s t r u c t c o n t e x t { i n t v a l ; } ; C Function Pointer i n t adder ( s t r u c t c o n t e x t cx, i n t x ) { r e t u r n cx >a + x ; } / Usage / s t r u c t c o n t e x t c ; c. v a l = ; i n t y = adder ( c, 2 ) ; Java Class // D e f i n i t i o n c l a s s Adder { p u b l i c i n t a ; p u b l i c Adder ( i n t a ) { a = a ; } p u b l i c i n t c a l l ( i n t x ) { r e t u r n x+a ; } } // Usage Adder A = new Adder ( ) ; i n t y = A. c a l l ( 2 ) ; Dantam (Mines CSCI, RPM) Lisp Spring / 88

48 Functional Programming Closures Closure in Lisp Local Function ( l e t ( ( a ) ) ( l a b e l s ( ( adder ( x ) (+ x a ) ) ) ( adder 2 ) ) ) Lambda Expression ( l e t ( ( a ) ) ( f u n c a l l ( lambda ( x ) (+ x a ) ) 2 ) ) Dantam (Mines CSCI, RPM) Lisp Spring / 88

49 Functional Programming Recursion Example: Recursion Iterative Recursive Function accumulate(s) a ; 2 i ; 3 while i < S do 4 a a + S i ; 5 return a; Function accumulate(s) if S then // Recursive Case 2 return car(s) + accumulate (cdr (S)); 3 else // Base Case 4 return ; Dantam (Mines CSCI, RPM) Lisp Spring / 88

50 Functional Programming Recursion Example: Recursive Accumulate in Lisp Recursive Implementation of Accumulate ( defun accumulate ( l i s t ) ( i f l i s t ; ; r e c u r s i v e c a s e (+ ( c a r l i s t ) ( accumulate ( cdr l i s t ) ) ) ; ; base c a s e ) ) Dantam (Mines CSCI, RPM) Lisp Spring 28 5 / 88

51 Functional Programming Recursion Example: Recursive Accumulate Execution Trace (accumulate ( 2 3)) Recursive Implementation of Accumulate ( defun accumulate ( l i s t ) ( i f l i s t ; ; r e c u r s i v e c a s e (+ ( c a r l i s t ) ( accumulate ( cdr l i s t ) ) ) ; ; base c a s e ) ) (+ (accumulate (2 3))) (+ (+ 2 (accumulate (3)))) (+ (+ 2 (+ 3 (accumulate nil)))) (+ (+ 2 (+ 3 ))) Dantam (Mines CSCI, RPM) Lisp Spring 28 5 / 88

52 Functional Programming Recursion Exercise: Recursive Reverse (a a... a n a n ) reverse (a n a n... a a ) Procedure reverse(l) Dantam (Mines CSCI, RPM) Lisp Spring / 88

53 Functional Programming Functional Operators Map Definition (map) Apply a function to every member of a sequence. map : (D R) }{{}}{{} D n }{{} R n function sequence result Function Application (f (s ), f (s 2 ),..., f (s n )) Dantam (Mines CSCI, RPM) Lisp Spring / 88

54 Functional Programming Functional Operators Map Pseudocode Procedural Function map(f,s) foreach s i S do 2 r i f (s i ); 3 return r; Recursive Function map(f,s) if S then // Recursive Case 2 a f (car(s)); 3 b map (f, cdr (S)); 4 return cons(a, b) 5 else // Base Case 6 return (); Dantam (Mines CSCI, RPM) Lisp Spring / 88

55 Functional Programming Functional Operators Map in Lisp Map in Lisp (map l i s t ; r e s u l t type ( lambda ( x ) (+ x ) ) ; f u n c t i o n ( l i s t 2 3 ) ) ; sequence ; ; RESULT : (2 3 4) Dantam (Mines CSCI, RPM) Lisp Spring / 88

56 Functional Programming Functional Operators Example: A Map Implementation Example Implementation of Map ( defun mymap ( f u n c t i o n l i s t ) ( l a b e l s ( ( h e l p e r ( l i s t ) ( i f l i s t ; ; R e c u r s i v e Case : ( cons ( f u n c a l l f u n c t i o n ( c a r l i s t ) ) ( h e l p e r ( cdr l i s t ) ) ) ; ; Base Case : n i l ) ) ) ( h e l p e r l i s t ) ) ) Dantam (Mines CSCI, RPM) Lisp Spring / 88

57 Functional Programming Functional Operators Fold-left Definition (fold-left) Apply a binary function to every member of a sequence and the result of the previous call, starting from the left-most (initial) element. fold-left : (Y X Y) Y }{{} function }{{} init. }{{} X n sequence Y }{{} result Function Application... f f y x x f... x n Dantam (Mines CSCI, RPM) Lisp Spring / 88

58 Functional Programming Functional Operators Fold-left Pseudocode Procedural Function fold-left(f,y,x) i ; 2 while i < X do 3 y f (y, X i ) ; 4 return y; Recursive Function fold-left(f,y,x) if X then // Recursive Case 2 y f (y, car(x )); 3 return fold-left (f, y, cdr (X )); 4 else // Base Case 5 return y; Dantam (Mines CSCI, RPM) Lisp Spring / 88

59 Functional Programming Functional Operators Fold-left in Lisp Fold-Left in Lisp ( reduce # + ; f u n c t i o n ( 2 3) ; sequence : i n i t i a l v a l u e ) ; ; ; R e s u l t 6 Dantam (Mines CSCI, RPM) Lisp Spring / 88

60 Functional Programming Functional Operators Exercise: Fold-Left Reverse (a a... a n a n ) reverse (a n a n... a a ) Procedure reverse(l) Dantam (Mines CSCI, RPM) Lisp Spring 28 6 / 88

61 Functional Programming Functional Operators Fold-right Definition (fold-right) Apply a binary function to every member of a sequence and the result of the previous call, starting from the right-most (final) element. fold-right : (X Y Y) Y }{{} function }{{} init. }{{} X n sequence Y }{{} result Function Application f x x f f f x n y Dantam (Mines CSCI, RPM) Lisp Spring 28 6 / 88

62 Functional Programming Functional Operators Fold-right Pseudocode Procedural Function fold-right(f,y,x) i X ; 2 while i do 3 y f (X i, y) ; 4 return y; Recursive Function fold-right(f,y,x) if X then // Recursive Case 2 y fold-right (f, y, cdr (X )); 3 return f (car(x ), y ); 4 else // Base Case 5 return y; Dantam (Mines CSCI, RPM) Lisp Spring / 88

63 Functional Programming Functional Operators Fold-right in Lisp Fold-Right in Lisp ( reduce # ; f u n c t i o n ( 2 3) ; sequence : i n i t i a l v a l u e : from end t ) ; ; ; R e s u l t Dantam (Mines CSCI, RPM) Lisp Spring / 88

64 Functional Programming Functional Operators MapReduce (parallel) map (serial) reduce/fold Provides scalability, fault-tolerance Implementations Google MapReduce Apache Hadoop Function MapReduce(f,g,X) Y parallel-map(f, X ); 2 return reduce(g, Y ); Dantam (Mines CSCI, RPM) Lisp Spring / 88

65 Programming Environment Outline Lisp Common Lisp by Example Implementation Details Typing Memory Management Functional Programming Closures Recursion Functional Operators Programming Environment Appendix Dantam (Mines CSCI, RPM) Lisp Spring / 88

66 Programming Environment Lisp Programming Environment C Programming Lisp Programming Lisp on unix source code compile binary source code edit,compile,debug editor lisp edit output debug output Dantam (Mines CSCI, RPM) Lisp Spring / 88

67 Programming Environment Demo SLIME, pstree Read-Eval-Print-Loop (REPL) DEFUN DISASSEMBLE Re-DEFUN Dantam (Mines CSCI, RPM) Lisp Spring / 88

68 Programming Environment SLIME Basics C: control M: Meta / Alt Frequently used: C-c C-k Compile and load file C-x C-e Evaluate expression before the point C-M-x Evaluate defun surround the point See SLIME drop-down in menu bar for more Dantam (Mines CSCI, RPM) Lisp Spring / 88

69 Programming Environment Summary Lisp Common Lisp by Example Implementation Details Typing Memory Management Functional Programming Closures Recursion Functional Operators Programming Environment Appendix Dantam (Mines CSCI, RPM) Lisp Spring / 88

70 Appendix Outline Lisp Common Lisp by Example Implementation Details Typing Memory Management Functional Programming Closures Recursion Functional Operators Programming Environment Appendix Dantam (Mines CSCI, RPM) Lisp Spring 28 7 / 88

71 Appendix L Hôpital s Rule Evaluate limits using derivatives when f (a) g(a) (( ) ( )) lim f (x) = lim g(x) = x a x a (similarly for ): = ( f (x) lim x a g(x) = lim f ) (x) x a g (x) Dantam (Mines CSCI, RPM) Lisp Spring 28 7 / 88

72 Appendix LET Creates a new scope and variable bindings Dantam (Mines CSCI, RPM) Lisp Spring / 88

73 Appendix Example: LET C Block Scope C Lisp Output { } i n t a = ; i n t b = ; p r i n t f ( (%d %d )\ n, a, b ) ; ( l e t ( ( a ) ( b 2 ) ) ( p r i n t ( l i s t a b ) ) ) ( 2) Dantam (Mines CSCI, RPM) Lisp Spring / 88

74 Appendix Example: LET Scope Nesting C Lisp Output { } i n t a = ; p r i n t f ( %d\n, a ) ; { i n t a = 2 ; p r i n t f ( %d\n, a ) ; } p r i n t f ( %d\n, a ) ; ( l e t ( ( a ) ) ( p r i n t a ) ( l e t ( ( a 2 ) ) ( p r i n t a ) ) ( p r i n t a ) ) 2 Dantam (Mines CSCI, RPM) Lisp Spring / 88

75 Appendix Example: LET Parallel assignments Lisp ( l e t ( ( a ) ( b 2 ) ) ( l e t ( ( a 3) ( b a ) ) ( p r i n t ( l i s t a b ) ) ) ) Output (3 ) Dantam (Mines CSCI, RPM) Lisp Spring / 88

76 Appendix Example: LET* Consecutive assignments Lisp ( l e t ( ( a ) ( b 2 ) ) ( l e t ( ( a 3) ( b a ) ) ( p r i n t ( l i s t a b ) ) ) ) Output (3 3) Dantam (Mines CSCI, RPM) Lisp Spring / 88

77 Appendix DOTIMES Iterate a for n steps Dantam (Mines CSCI, RPM) Lisp Spring / 88

78 Appendix Example: DOTIMES f o r ( i n t i = ; i < 5 ; i ++ ) { p r i n t f ( %d, i ) ; } C Lisp ( dotimes ( i 5) ( p r i n t i ) ) Output Dantam (Mines CSCI, RPM) Lisp Spring / 88

79 Appendix DOLIST Iterate over a list Dantam (Mines CSCI, RPM) Lisp Spring / 88

80 Appendix Example: DOLIST Lisp ( d o l i s t ( x ( a b c ) ) ( p r i n t x ) ) Output A B C Dantam (Mines CSCI, RPM) Lisp Spring 28 8 / 88

81 Appendix Example: LOOP counting Lisp ( loop f o r i below 5 do ( p r i n t i ) ) Output Dantam (Mines CSCI, RPM) Lisp Spring 28 8 / 88

82 Appendix Example: LOOP list iteration Lisp ( loop f o r x i n ( a b c ) do ( p r i n t x ) ) Output A B C Dantam (Mines CSCI, RPM) Lisp Spring / 88

83 Appendix Example: LOOP collecting Lisp ( l e t ( ( x ( loop f o r i below 5 when ( evenp i ) c o l l e c t i ) ) ) ( p r i n t x ) ) Output ( 2 4) Dantam (Mines CSCI, RPM) Lisp Spring / 88

84 Appendix Example: REDUCE collecting Lisp ( l e t ( ( x ( reduce ( lambda ( a x ) ( i f ( evenp x ) ( cons x a ) a ) ) ( ) : i n i t i a l v a l u e n i l ) ) ) Output ( 2 4) ( p r i n t x ) ) Dantam (Mines CSCI, RPM) Lisp Spring / 88

85 Appendix Case Control structure Selects clause that matches the test argument Dantam (Mines CSCI, RPM) Lisp Spring / 88

86 Appendix Example: CASE C switch ( B ) { case A : puts ( Got A ) ; break ; case B : puts ( Got B ) ; break ; case C : puts ( Got C ) ; break ; } Lisp ( case b ( a ( p r i n t Got A ) ) ( b ( p r i n t Got B ) ) ( c ( p r i n t Got C ) ) Output Got B Dantam (Mines CSCI, RPM) Lisp Spring / 88

87 Appendix Example: S-Expression to XML Lisp ( l a b e l s ( ( v i s i t ( e i ) ( i f ( l i s t p e ) ( progn ; ; opening tag ( format t &< A> ( c a r e ) ) ; ; Re cur se on arguments ( d o l i s t ( e ( cdr e ) ) ( v i s i t e (+ i 2 ) ) ) ; ; C l o s i n g tag ( format t &</ A> ( c a r e ) ) ) ; ; Else, p r i n t the element ( format t & A e ) ) ) ) ( v i s i t ( and x ( or y z ) ) ) ) Output <AND> X <OR> Y Z </OR> </AND> Dantam (Mines CSCI, RPM) Lisp Spring / 88

88 Appendix Example: S-Expression to XML w/ indentation Lisp ( l a b e l s ( ( v i s i t ( e i ) ( l e t ( ( i n d e n t ( make string i : i n i t i a l e l e m e n t #\Space ) ) ) ( i f ( l i s t p e ) ( progn ; ; opening tag ( format t & A< A> i n d e n t ( c a r e ) ) ; ; Recurse on arguments ( d o l i s t ( e ( cdr e ) ) ( v i s i t e (+ i 2 ) ) ) ; ; C l o s i n g tag ( format t & A</ A> i n d e n t ( c a r e ) ) ) ; ; Else, p r i n t the element ( format t & A A i n d e n t e ) ) ) ) ) ( v i s i t ( and x ( or y z ) ) ) ) Output <AND> X <OR> Y Z </OR> </AND> Dantam (Mines CSCI, RPM) Lisp Spring / 88