Purpose: Loose ends / CLOS in 10 minutes / revision quiz / summary

12.1 Loose ends

There are a couple of specific points that I want to tie up. The first is that one of the great things about lisp is that it offers so many different ways of expressing your intent. Recall from the first lecture:

A declarative language is a language in which you describe the problem you are working on and the computer decides how to solve it. Lisp and Prolog are declarative languages.

On the other hand a procedural language is a language in which you tell the computer what to do. The machine will then do what you tell it and you hope that what it tells you is the answer to the question you wanted to ask. Pascal is a procedural language.

(def-url "/" ...)     ; define root page of my web server

For example, the following would all find the position in the list things of a sublist of length 1. The first is fairly compact, and fine if you know how to use the :key argument to position. The next is almost as neat but depends on knowing about position-if, the third works but might be criticized for wasteful allocation (generating a list of length (length things) and then throwing it away again). The dolist form uses "primitive" parts, which is fine and might even in some circumstances run faster than the others; the mapc-closure solution is quite frankly revolting. Presumably, we could also have written a recursive function to do the search.

(position 1 things :key 'length)

(position-if #'(lambda (x) (= (length x) 1)) things)

(position 1 (mapcar 'length things))

(let ((where 0))
  (dolist (x things)
    (when (= (length x) 1)
      (return where))
    (incf where)))

(block found
  (let ((where 0))
    (mapc #'(lambda (x)
              (when (and x (not (cdr x)))
                (return-from found where))
              (incf where))
          things))
  nil)

(or (gethash key table)
    default)

(gethash key table default)

You'll find many cases like this in lisp: where different treatments can have similar results but for fine tuning you have to really know how each operator works.

12.2 What did we miss out?   (incorporating "CLOS in ten minutes"^TM)

We have covered around 160 Common Lisp symbols - looked at one way that's one sixth of the language. In practice, it's considerably more than that because a lot of the remaining symbols involve more book-work to cover less ground. (Or: less dramatic ground.) I'd reckon we're about half-way there. We didn't touch:

• packages (other than in passing)
• streams (other than in passing)
• pathnames (other than very much in passing)
• compilation issues
• declarations
• optimization
• defining your own setf behaviour
• multiple values (other than in passing)
• the complex loop macro
• the condition system
• advanced macro building techniques
• extending the syntax
• vast numbers of functions dealing with lists, arrays, string, characters, numbers

So why use Lisp? Because it is

• Standardized
• Extensible
• Dynamic
• Large
• Powerful
• Robust
• Reliable
• Y2K proof ;-)
• Flexible
• Cheap
• High-level
• Interactive
• Elegant
• Fun

• simple consistent syntax
• a rich set of datatypes
• run-time (dynamic) typing
• automatic memory management (garbage collection)
• a fully integrated object system (CLOS)
• sophisticated error handling
• stunningly powerful macro system ("programs as data")
• features (such as unwind-protect and closures) which you simply won't find elsewhere

• large and complex
• server side
• non-stop

1. How would you add (i.e. insert) an extra element to the start of a list?
2. How could you splice two lists together?
3. How would you add (i.e. insert) an extra element to the end of a list?
4. Suppose you wanted to perform some operation on each element of a list: how could you do this? (3 different answers...)
5. What kinds of things can you use lists for?
6. Give an example of a special operator.
7. How could you find out the variable value of a symbol?
8. How could you find out whether a symbol had a functional value?
9. Give an example of a lisp object which is of two types, neither of which is a subtype of the other.
10. True or false: every valid expression, when evaluated, returns a value?
11. True or false: and is a function?
12. How could you define a function so that it can take 0 or more parameters?
13. How do you give a default value for an optional argument?
14. Give five lisp datatypes.
15. What does eval do?
16. What defining forms do you know?
17. Give some advantages of macros.
18. Give an example of an iterative operator.
19. Give 3 different equality predicates.
20. How would you decide which equality predicate to use?
21. If you wanted to find an operator which worked on strings, you might look in a reference manual in the chapter on string operators. Which other chapters would you look in?
22. What is tail recursion?
23. How do you write comments in lisp code?
24. What conventions do you know for lisp code?
25. How would you choose whether to use structures, hash-tables, lists or arrays for a particular application?
26. What kinds of applications do you think lisp is good for?
27. How do you ask a lisp programmer if they want a drink?

• Implement a recursive function to find the position in a given list of a sublist of length 1.
• Implement the function append. Is your solution elegant? fast? robust?
• Implement a function which takes a lisp object and says something useful about it (the way that describe does).
• Go back through all the practicals and exercises and complete everything you missed out first time through.

• Graham chapters 1-8 and 10
• Take at least one look through chapter 13 and appendix D of Graham.