Writing LISP functions

1
Writing LISP functions
2
COND

• Rule 1 Unless the function is extremely simple,
  begin with a COND
• If you can write the function body in one line,
  do it.
• If it's more complicated, use COND to break it
  into cases.

3
NULL

• Rule 2 Test for a base case firstthis usually
  means testing for NULL (empty) list
• You should always handle the base (simplest)
  cases first.
• When you are working with lists, the simplest
  case is usually the empty list.
• Usually, you recur with the CDR of the list.

4
Avoid multiple base cases

• Rule 2a Avoid having more than one base case.
• You must always recur with a simpler case.
• When you are working with lists, the simplest
  case is usually the empty list.
• Usually, you recur with the CDR of the list.

5
Example multiple base cases
(DEFUN UNION (SET1 SET2) (COND ((NULL
SET1) SET2) ((NULL SET2) SET1) bad
idea! ((MEMBER (CAR SET1) SET2)
(UNION (CDR SET1) SET2)) (T (CONS
(CAR SET1) (UNION (CDR SET1) SET2)))
) ) )
6
Use CAR, recur with CDR

• Rule 3 Do something with the CAR, and recur with
  the CDR.
• Recursion involves doing some nonrecursive work,
  doing some recursive work, and combining the two.
• You typically do the simple work on the CAR and
  recur with the CDR, then combine.

7
Deleting elements

• Rule 3a To delete the CAR, just ignore it and
  recur with the CDR.
• Rule 3b To keep the CAR unchanged, CONS it onto
  the result of recurring with the CDR.
• Extra work deciding whether to keep the CAR.
• Combining results adding the CAR to the result
  of recurring with the CDR.

8
ExampleRemoving atoms from a list
(DEFUN REMATOMS (L) (COND ((NULL L)
L) ((ATOM (CAR L)) (REMATOMS (CDR L)))
(T (CONS (CAR L) (REMATOMS (CDR L)))) ) )
1
2
3a
3b
9
Transforming elements

• Rule 3c To transform the elements of a list,
  CONS the transformed CAR onto the result of
  recurring with the CDR.
• Extra work transforming the CAR.
• Recur with the CDR, as usual.
• Combine the results with CONS.

10
ExampleAdding one to each element
(DEFUN ADDONE (L) (COND ((NULL L)
L) (T (CONS (1 (CAR L))
(ADDONE (CDR L)))) ) )
1
2
3c
11
Accumulating information

• Rule 4 In each case of a COND you can use the
  fact that all previous tests have failed.
• If you have tested whether a list is empty, later
  cases can take its CAR and CDR.
• If you have decided that the CAR is of no
  interest, you can ignore it and use the CDR.

12
Example of accumulating information
(DEFUN MEMBER (A LAT) (COND
((NULL LAT) NIL) ((EQ A (CAR LAT))
T) (T (MEMBER A (CDR LAT))) ) )
4
4

• In fact, every time you use COND you are
  accumulating information as you go

13
Ending the COND

• Rule 5 Use T as the last test in a COND.
• If you flow off the end of a COND, the result
  is undefined. This is a Bad Thing.
• You want to be sure you cover every case, but
  sometimes there are unexpected cases.
• Not every integer is positive, negative, or zero.
• T protects you from the forgotten cases.

14
Example UNION
(DEFUN UNION (SET1 SET2) (COND ((NULL
SET1) SET2) ((MEMBER (CAR SET1) SET2)
(UNION (CDR SET1) SET2)) (T
(CONS (CAR SET1) (UNION (CDR SET1)
SET2))) ) ) )
1
2
3,3a
5, 3, 3b
15
The End