Datasets:
Tasks:
Text Generation
Languages:
English
| <html> | |
| <head> | |
| <title>LISP Tutorial Lecture 4: Imperative Programming</title> | |
| </head> | |
| <body bgcolor=ffffff> | |
| <h1>LISP Tutorial Lecture 4: Imperative Programming</h1> | |
| <h2>Imperative vs Functional Programming</em> | |
| <p>The fragment of LISP we have learned so far is purely functional. | |
| We program by defining mathematical functions. Programming this way | |
| has the benefit of <em>referential transparency</em>, which means that | |
| an experession has the same value and the same behavior, no matter | |
| where it is located, and how many times it is invoked. For example, | |
| the following function always returns 4 when an input 2 is supplied: | |
| <pre> | |
| (defun double (x) (* 2 x)) | |
| </pre> | |
| Such programs are easy to develop and debug. The only effect of calling | |
| a function is the returned value. Functions become a lot harder to | |
| understand and debug when we allow them to produce <em>side effects</em>, that | |
| is, affecting subsequent computation in ways other than returning a value. | |
| This style of programming, in which side effect is not only permissible | |
| but is also the primary means by which we program, is | |
| called <em>imperative programming</em>. This is not something new, but | |
| is in fact the very kind of programming habits that you have acquired since | |
| you learned your first programming language (e.g. C/C++, Pascal, Java). | |
| Because of this, we intentionally leave the topic of imperative programming to | |
| the end of this series of tutorials. We do so since you already know so | |
| much about imperative programming, and since, in my taste, teaching it | |
| before teaching functional programming would only reinforce some of | |
| the bad habits programmers usually have, and thereby luring you to | |
| write C code with LISP, which, of course, make it harder to finish | |
| your assignment on time. | |
| <h2>Variables</h2> | |
| <p>Imperative programming is made possible by the notion of | |
| <em>program state</em>. The behavior of an expression depends | |
| on the exact state a program is in. In turn, the state of | |
| a program is defined by, guess what, <em>variables</em>. | |
| <p>Suppose we want to create a global counter to keep track of the | |
| times some computational events occur. | |
| Common LISP allows us to define global variables as follows. | |
| <pre> | |
| USER(7): (defparameter *counter* 0 "Counter to keep track of ....") | |
| *COUNTER* | |
| USER(8): (setf *counter* (1+ *counter*)) | |
| 1 | |
| USER(9): *counter* | |
| 1 | |
| USER(10): (setf *counter* (1+ *counter*)) | |
| 2 | |
| USER(11): *counter* | |
| 200 | |
| </pre> | |
| We use the <tt>defparameter</tt> special form to define | |
| a global variable <tt>*counter*</tt>, with zero as its | |
| initial value. We also decorate the declaration by a | |
| documentation string. We then use the <tt>setf</tt> | |
| special form to assign new values to the variable. | |
| The <tt>setf</tt> special form returns the new value of | |
| the variable. | |
| Lastly, evaluating the variable gives its current value. | |
| Notice that <tt>*counter*</tt> is evaluated to two different values | |
| at different point of time. This is something you will never see if | |
| you work with purely functional programs. | |
| <p>Suppose we actually want this counter to reset to zero when it | |
| reaches a user defined threshold. We would encapsulate this | |
| service into the following definitions: | |
| <pre> | |
| (defparameter *counter* 0 | |
| "Counter to keep track of ....") | |
| (defparameter *threshold* 4 | |
| "Counter will be reset to zero when its value reaches this threshold.") | |
| (defun counter-inc () | |
| "Increment global counter by one." | |
| (if (>= (1+ *counter*) *threshold*) | |
| (setf *counter* 0) | |
| (setf *counter* (1+ *counter*)))) | |
| (defun counter-value () | |
| "Return current value of global counter." | |
| *counter*) | |
| (defun counter-threshold () | |
| "Return current threshold of global counter." | |
| *threshold*) | |
| </pre> | |
| <pre> | |
| USER(24): (counter-value) | |
| 0 | |
| USER(25): (counter-inc) | |
| 1 | |
| USER(26): (counter-inc) | |
| 2 | |
| USER(27): (counter-inc) | |
| 3 | |
| USER(28): (counter-threshold) | |
| 4 | |
| USER(29): (counter-inc) | |
| 0 | |
| </pre> | |
| <p>The function <tt>counter-inc</tt> can also be defined as follows: | |
| <pre> | |
| (defun counter-inc () | |
| "Increment global counter by one." | |
| (if (>= (1+ *counter*) *threshold*) | |
| (setf *counter* 0) | |
| (incf *counter*))) | |
| </pre> | |
| <h2>Sequencing</h2> | |
| <p>With the possibility of state alteration, we also need a new kind | |
| of programming construct --- <em>sequencing</em>. This allows us to | |
| perform multiple state-alterating operations, one after another. | |
| For example, we might want to introduce another function to our global | |
| counter abstraction: a function to modify the value of <tt>*threshold*</tt> | |
| on the fly: | |
| <pre> | |
| (defun counter-set-threshold (th) | |
| "Set counter threshold to TH." | |
| (setf *threshold* th) | |
| (if (>= *counter* *threshold*) | |
| (setf *counter* 0)) | |
| *threshold*) | |
| </pre> | |
| The function sets the global value of <tt>*threshold*</tt> to a new value, | |
| and then checks if the current counter value has exceeded the new threshold. | |
| If the check succeeds, then the counter is reset to zero. Lastly, the | |
| function evaluates and returns the last expression, which is simply the | |
| new value of <tt>*threshold*</tt>. Notice that | |
| in this example the body of a function is no longer one expression, but | |
| a sequence of expressions. They are evaluated in order, and the value | |
| of the last expression is returned as a value of the sequence. | |
| The effect is demonstrated as in the following trace: | |
| <pre> | |
| USER(2): (counter-value) | |
| 0 | |
| USER(3): (counter-inc) | |
| 1 | |
| USER(4): (counter-inc) | |
| 2 | |
| USER(5): (counter-inc) | |
| 3 | |
| USER(6): (counter-inc) | |
| 0 | |
| USER(7): (counter-inc) | |
| 1 | |
| USER(8): (counter-inc) | |
| 2 | |
| USER(9): (counter-set-threshold 2) | |
| 0 | |
| USER(10): (counter-value) | |
| 0 | |
| </pre> | |
| <p>In fact, forms like <tt>let</tt>, <tt>let*</tt>, <tt>when</tt> and | |
| <tt>unless</tt> all admit sequences as their bodies. The <tt>cond</tt> | |
| form allows sequencing in the body of each alternative. The exception | |
| is <tt>if</tt>, due to its syntax. However, you can always get around | |
| by introducing a <tt>let</tt> form in the alternatives or by using | |
| other conditional forms. | |
| <p>Before we move on, notice that we can rewrite the <tt>counter-inc</tt> | |
| function as follows: | |
| <pre> | |
| (defun counter-inc () | |
| "Increment global counter by one." | |
| (if (>= (1+ *counter*) *threshold*) | |
| (setf *counter* 0) | |
| (incf *counter*))) | |
| </pre> | |
| The <tt>(incf x)</tt> form is simply a shorthand for <tt>(setf x (+ x 1))</tt>. | |
| In general, the following are useful shorthands when developing imperative | |
| programs: | |
| <p> | |
| <table border=1> | |
| <tr> | |
| <th>Shorthand</th><th>Meaning</th> | |
| </tr> | |
| <tr> | |
| <td><tt>(incf x delta)</tt></td> | |
| <td><tt>(setf x (+ x delta))</td> | |
| </tr> | |
| <tr> | |
| <td><tt>(incf x)</tt></td> | |
| <td><tt>(incf x 1)</tt></td> | |
| </tr> | |
| <tr> | |
| <td><tt>(decf x delta)</tt></td> | |
| <td><tt>(setf x (- x delta))</tt></td> | |
| </tr> | |
| <tr> | |
| <td><tt>(decf x)</tt></td> | |
| <td><tt>(decf x 1)</tt></td> | |
| </tr> | |
| <tr> | |
| <td><tt>(push e x)</tt></td> | |
| <td><tt>(setf x (cons e x))</tt></td> | |
| </tr> | |
| <tr> | |
| <td><tt>(pop x)</tt></td> | |
| <td><tt>(let ((e (first x))) (setf x (rest x)) e)</tt></td> | |
| </tr> | |
| </table> | |
| <p><hr><b>Exercise:</b> Create a global stack abstraction, with | |
| interface functions for performing pushing and poping. | |
| <hr> | |
| <h2>Closures</h2> | |
| <p>The above method for defining an abstraction is not good enough. | |
| For one, the global variables are not encapsulated. There is | |
| nothing to forbid a careless user to change the value of <tt>*counter*</tt> | |
| in ways violating the invariants of the counter abstraction. | |
| To enforce this, we make use of <em>local variables</em> and <em>closures</em>. | |
| <p>As one would expect, the names introduced by a <tt>let</tt> form turns | |
| out not to be a name binding to some immutable values. The names refer | |
| to local variables. Such variables follow typical <em>lexical scoping | |
| rules</em>, so that LISP always looks up the innermost variable definition | |
| when a variable name is to be evaluated. | |
| <p>What is more interesting is that, due to the ability to return | |
| functions as values, the local variable has a life span longer than | |
| the expression defining it. Consider the following example: | |
| <pre> | |
| USER(20): (setf inc (let ((counter 0)) | |
| #'(lambda () | |
| (incf counter)))) | |
| #<Interpreted Closure (unnamed) @ #x53688a> | |
| USER(21): (funcall inc) | |
| 1 | |
| USER(22): (funcall inc) | |
| 2 | |
| USER(23): (funcall inc) | |
| 3 | |
| </pre> | |
| We assign a value to the global variable <tt>inc</tt>. That value | |
| is obtained by first | |
| defining local variable <tt>counter</tt> using <tt>let</tt>, | |
| and then within the lexical scope of the local variable, | |
| a lambda expression is evaluated, | |
| thereby creating an annonymous function, which is returned as a value | |
| to be assigned to <tt>inc</tt>. The most interesting part | |
| is in the body of that lambda expression --- it increments | |
| the value of the local variable <tt>counter</tt>! When the lambda | |
| expression is returned, the local variable persists, and is accessible | |
| only through the annonymous function. | |
| <p>The thing to remember from this example is that, in other kinds | |
| of languages like Pascal and C/C++ the lexical scope of a local | |
| variable somehow coincide with its life span. After executation | |
| passes beyond the boundary of a lexical scope, all the local | |
| variables defined within it cease to exist. This is not true | |
| in languages supporting higher-order functions, in particular, | |
| expressions that return functions as values. | |
| However, that is not to say that lexical scoping does not | |
| hold in such languages. In the contrary, lexical scoping is | |
| enforced strictly, and therefore the only place from which | |
| you can alter the value of <tt>counter</tt> is, as every | |
| true believer of lexical scoping would agree, within the lexical | |
| scope of the variable --- the lambda expression. As a result, | |
| the counter state is effectively encapsulated. The only | |
| way to modify it is by going through the annonymous function stored | |
| in <tt>inc</tt>. The technical term to refer to this <em>thing</em> | |
| that is stored in <tt>inc</tt>, this thing that at the same time | |
| captures both the definition of a function and the variables | |
| referenced within the function body is called a <em>function closure</em>. | |
| <p>What if we want to define multiple interface functions for | |
| the encapsulated counter? Simple, just return all of them: | |
| <pre> | |
| USER(34): (setf list-of-funcs (let ((counter 0)) | |
| (list #'(lambda () | |
| (incf counter)) | |
| #'(lambda () | |
| (setf counter 0))))) | |
| (#<Interpreted Closure (unnamed) @ #x5408e2> | |
| #<Interpreted Closure (unnamed) @ #x540912>) | |
| USER(35): (setf inc (first list-of-funcs)) | |
| #<Interpreted Closure (unnamed) @ #x5408e2> | |
| USER(36): (setf reset (second list-of-funcs)) | |
| #<Interpreted Closure (unnamed) @ #x540912> | |
| USER(37): (funcall inc) | |
| 1 | |
| USER(38): (funcall inc) | |
| 2 | |
| USER(39): (funcall inc) | |
| 3 | |
| USER(40): (funcall reset) | |
| 0 | |
| USER(41): (funcall inc) | |
| 1 | |
| </pre> | |
| <p><hr><b>Exercise:</b> Define an encapsulated global stack. | |
| <hr> | |
| <h2>Poor-Man's Object</h2> | |
| <p>Having only one instance of this encapsulated counter abstraction | |
| is not good enough. Imagine cases when we need multiple instances | |
| of such counters, each having its own state. Well, the answer | |
| is simple, we just evaluate the function-returning <tt>let</tt> | |
| form everytime we need a new instance of counter. Since, a new | |
| local variable will be created everytime we evaluate the <tt>let</tt> | |
| form, the function closure that is returned each time will be | |
| associated with a different incarnation of the local variable <tt>counter</tt>. | |
| To automate this process, of course we define a <em>constructor</em> | |
| for such closures: | |
| <pre> | |
| (defun make-counter () | |
| "Create a new instance of a counter object." | |
| (let ((counter 0)) | |
| (list #'(lambda () | |
| (incf counter)) | |
| #'(lambda () | |
| (setf counter 0))))) | |
| </pre> | |
| Notice how this allows us to maintain independently encapsulated states: | |
| <pre> | |
| USER(44): (setf c1 (make-counter)) | |
| (#<Interpreted Closure (:INTERNAL MAKE-COUNTER) @ #x543f00> | |
| #<Interpreted Closure (:INTERNAL MAKE-COUNTER) @ #x543f30>) | |
| USER(44): (setf c2 (make-counter)) | |
| (#<Interpreted Closure (:INTERNAL MAKE-COUNTER) @ #x543f62> | |
| #<Interpreted Closure (:INTERNAL MAKE-COUNTER) @ #x543f92>) | |
| USER(45): (funcall (first c1)) | |
| 1 | |
| USER(46): (funcall (first c1)) | |
| 2 | |
| USER(47): (funcall (second c1)) | |
| 0 | |
| USER(48): (funcall (first c2)) | |
| 1 | |
| USER(49): (funcall (first c2)) | |
| 2 | |
| USER(50): (funcall (first c2)) | |
| 3 | |
| USER(51): (funcall (first c1)) | |
| 1 | |
| USER(52): (funcall (first c1)) | |
| 2 | |
| USER(53): (funcall (second c2)) | |
| 0 | |
| USER(54): (funcall (first c1)) | |
| 3 | |
| </pre> | |
| <p>To make invoking counter interface functions easier, we can | |
| define the following shorthands: | |
| <pre> | |
| (defun counter-increment (counter) | |
| "Increment counter." | |
| (funcall (first counter))) | |
| (defun counter-reset (counter) | |
| "Reset counter." | |
| (funcall (second counter))) | |
| </pre> | |
| And now we have an all-rounded counter abstraction. | |
| <pre> | |
| USER(56): (counter-increment c1) | |
| 4 | |
| USER(57): (counter-reset c1) | |
| 0 | |
| </pre> | |
| <p>The moral of this store is that, function closures are <em>encapsulated | |
| states</em>. They are a poor-man's version of objects, which, after all, | |
| are nothing but encapsulated states. (Yes, I am aware that Common LISP | |
| has a Common LISP Object System (CLOS), and there is no point of | |
| using closures in this manner if all we want is simply object orientation. | |
| But No, I want you to understand what higher-order functions buy | |
| you, and how they serve as a building block for other advanced | |
| programming language constructs. Lastly, I don't want you to spend | |
| time struggling to learn yet another object system.) | |
| <p><hr><b>Exercise:</b> Implement a constructor for your encapsulated | |
| stack abstraction. Define appropriate shorthands for | |
| convenient invocation of interface functions. | |
| <hr> | |
| <h2>Iterative Constructs</h2> | |
| <p>To round off this tutorial, we discuss something that you | |
| know so much about --- iterations. We start with something | |
| very simple: | |
| <pre> | |
| USER(1): (dotimes (i 10) (print i)) | |
| 0 | |
| 1 | |
| 2 | |
| 3 | |
| 4 | |
| 5 | |
| 6 | |
| 7 | |
| 8 | |
| 9 | |
| NIL | |
| </pre> | |
| The <tt>(dotimes (<em>i</em> <em>n</em>) | |
| <em>body</em>)</tt> form executes <em>body</em> <em>N</em> times. | |
| In addition, it defines a local variable <em>i</em>, which receives | |
| an integer value ranging from <em>0</em> to <em>n-1</em>. | |
| The body of the form could be a sequence of expressions. The form | |
| returns <tt>NIL</tt>. The <tt>(print <em>x</em>)</tt> form prints | |
| the LISP object <em>x</em> to the console. | |
| <p>A similar construct is defined for iterating through a list: | |
| <pre> | |
| USER(2): (dolist (i '(a b c d e)) (print i)) | |
| A | |
| B | |
| C | |
| D | |
| E | |
| NIL | |
| </pre> | |
| <p>The most general looping construct is the <tt>do</tt> form: | |
| <pre> | |
| (defun fibonacci (n) | |
| "Compute the N'th Fibonacci number." | |
| (do ((f1 0 f2) | |
| (f2 1 (+ f1 f2)) | |
| (i 0 (1+ i))) | |
| ((= i n) f2) | |
| ; empty body | |
| )) | |
| </pre> | |
| The first list following the <tt>do</tt> keyword is a list of | |
| local variables and their initializations and update forms. | |
| Each member of this list has the format <tt>(<em>var</em> | |
| <em>init-form</em> <em>update-form</em>)</tt>. | |
| Within this loop are defined three local variables <tt>f1</tt>, | |
| <tt>f2</tt> and <tt>i</tt>. The three initialization forms | |
| 0, 1 and 0 are evaluated first, and then assigned to the | |
| three locals simultaneously. In each subsequent iteration, | |
| the three update forms <tt>f2</tt>, <tt>(+ f1 f2)</tt> and | |
| <tt>(1+ i)</tt> will be evaluated first, and then the values | |
| are assigned to the three local variables simultaneously. | |
| The second list following the <tt>do</tt> keyword | |
| (i.e. <tt>((= i n) f2)</tt>) has the general format of | |
| <tt>(<em>exit-condition</em> <em>return-form</em>)</tt>. | |
| The exit condition <tt>(= i n)</tt> is checked after | |
| the initialization is done, or after the update is performed | |
| in subsequent iterations. If the test succeeds, then the | |
| return form is evaluated, and its value is returned. Otherwise, | |
| the body of the <tt>do</tt> form, which in this case is empty, | |
| will be executed with the updated value of the local variables. | |
| <p>Indefinite looping can be achieved using the <tt>(loop <em>body</em>)</tt> | |
| form. One may exit from such loop using the <tt>return-from</tt> form: | |
| <pre> | |
| (defun fib (n) | |
| "Compute the N'th Fibonacci number." | |
| (let ((f1 0) | |
| (f2 1) | |
| (i 0)) | |
| (loop | |
| (if (= i n) | |
| (return-from fib f2)) | |
| ; empty body | |
| (psetf f1 f2 | |
| f2 (+ f1 f2) | |
| i (1+ i))))) | |
| </pre> | |
| The <tt>fib</tt> function has the same meaning as the <tt>fibonacci</tt> | |
| function coded in terms of <tt>do</tt>. The <tt>psetf</tt> is a | |
| variation of <tt>setf</tt> that implements "parallel" assignment. | |
| </body> | |
| </html> |