ANSI Common Lisp 5. Control 16 June 2003

Blocks -- progn progn > (progn (format t “a”) (format t “b”) ( )) ab 23 The expressions within its body are evaluated in order, and the last value is returned.

Blocks -- progn For readability purpose, don’t use progn if there is an alternative (let, cond, …). (if (FOO x) (progn (print “hello”) 23) 34) (cond ((FOO x) (print “hello”) 23) (t 34))

Blocks -- block A block has a name, which is the first argument of block. At any point of the block body, return-from can halt evaluation and return a value. (block head (format t “Here we go”) (return-from head ‘idea) (format t “This statement won’t be evaluated”)

Blocks -- block A block can be named nil, where the return macro, instead of return-from, can return a value. (block nil (return 27)) Implicit block in defun (defun foo () (return-from foo 27)) (block foo (return-from foo 27))

Blocks -- block Implicit block named nil enclosed in all iterations. (dolist (x ‘(a b c d e)) (format t “~A “ x) (if (eql x ‘c) (return ‘done))) A B C DONE Neither return-from nor return will work outside of an explicit or implicit block. WRONG CODE: (mapcar #'(lambda (x) (if (eql x 'c) (return 'done) (format t "~A " x))) '(a b c d e))

Context -- let The let creates a new lexical context (group expressions). Within its body, new variables can be defined. (let ((x 7) (y 2)) (+ x y)) The variables defined in let body are local to the body. The variables from outer context are visible the let body.

Context -- let The let expression is essentially a lambda function call. (let ((x 7) (y 2)) (+ x y)) ((lambda (x y) (+ x y)) 7 2)

Context -- let The value of one let-created variable does NOT depend on other variables created by the same let. (let ((x 1)) (let ((x 2) (y (+ x 1))) y)) 2

Context -- let If we want the value of one let-created variable does depend on other variables created by the same let, we can use let*. (let ((x 1)) (let* ((x 2) (y (+ x 1))) y)) 3

Context – destructuring-bind The destructuring-bind is used to bind tree values to corresponding parts of tree. >(destructuring-bind (w (x y). z) ‘(a (b c) d e) (A B C (D E))

Conditional – if, when, unless if (if (oddp that) (format t “odd”)) when (when (oddp that) (format t “Hmm, that’s odd.”) (+ that 1)) unless (unless (oddp that) (format t “Hmm, that’s even.”) (+ that 1))

Conditional – cond, case cond (cond ((predicate 1) expressions 1)) ((predicate 2) (expression2 2)) … (t (expressions N))) case – compare a value against a series of constants (won’t be evaluated). (case mon ((jan mar may jul aug oct dec) 31) ((apr jun sept nov) 30) (feb (if (leap-year) 29 28)))

Iteration – do, do* Basic usage (do ((i 1 (+ i 1))) ((> i 5) ‘done) (format t “~A ~A~%” i (* i i)))) More variable updates (let ((x ‘a)) (do ((x 1 (+ x 1)) (y x x)) ((> x 5)) (format t “(~A ~A) “ x y))) (1 A) (2 1) (3 2) (4 3) (5 4)

Iteration – do, do* do* (let ((x ‘a)) (do ((x 1 (+ x 1)) (y x x)) ((> x 5)) (format t “(~A ~A) “ x y))) (1 1) (2 2) (3 3) (4 4) (5 5)

Iteration – dolist, dotimes dolist (dolist (x ‘(a b c d) ‘done) (format t “~A “ x)) A B C D DONE dotimes (iterates from 0 to n-1) (dotimes (x 5 x) (format t “~A “ x))

Iteration – mapc, mapcar mapc Always returns its second argument. (mapc #’(lambda (x y) (format t “~A “A “ x y)) ‘(hip flip slip) ‘(hop flop slop)) HIP HOP FLIP FLOP SLIP SLOP (hip flip slip) mapcar Takes a function and one or more lists as arguments, and returns the result of applying the function to elements taken from each list, until some list runs out. (mapcar #’list ‘( ) ‘(a b c)) ((1 A) (2 B) (3 C))

Multiple Values In CLISP, a function can return multiple values. The values function (values ‘a NIL (+ 2 4)) A NIL 6 If only one value is expected, all but the first will be discarded. (let ((x (values 1 2 3))) x) 1

Multiple Values The multiple-value-bind can receive multiple values (multiple-value-bind (x y z n) (values 1 2 3) (list x y z n)) (1 2 3 NIL) The multiple-value-call function (multiple-value-call #’+ (values 1 2 3)) 6 The multiple-value-list function (multiple-value-list (values ‘a ‘b ‘c)) (A B C)

Aborts – catch/throw catch/throw (defun super () (catch ‘abort (sub) (format t “We’ll never see this.”))) (defun sub () (throw ‘abort 99)) >(super) 99

Aborts – error, unwind-protect error The error function interrupts execution and pass the control to LISP break loop. unwind-protect The unwind-protect function ensures the remaining expressions will be evaluated even if the previous evaluation interrupts execution. The unwind-protect function is useful for clean- up or reset. For example, close the I/O stream when some errors come out.