Class 07: Recursion with Lists

Held: Wednesday, 29 January 2003

Summary: Today we investigate recursion over lists with a number of experiments.

Related Pages:

• EBoard
• Initial reading on recursion.
• Lab on recursion.

Assignments:

• Do Homework 1: Deep Recursion.
• Read Recursion with Natural Numbers.

Notes:

• What happens if an if lacks a false-part, as in (if (< x 0) x)?
• Any comments on the EBoards?
• I hope to return Lab writeup 1 to you on Friday.

Overview:

• Reflections on Recursion.
• Lab: Repetition with Recursion.

Patterns of Recursion in Lists

• I find it useful to think about the pattern one uses to design certain kinds of procedures.
• Here's the pattern of a typical recursive procedure:

  (define proc
    (lambda (val)
      (if (base-case-test)
          (base-case val)
          (combine (partof val)
                   (proc (update val))))))
  

• When the value you're working with is a list and your base case is the null list, the form is somewhat simpler:

  (define proc
    (lambda (lst)
      (if (null? lst)
          null-case
          (combine (onestep (car val))
                   (proc (cdr val))))))
  

• You may even find that there are some boolean procedures that don't even need an if. For example, here's one implementation of member that works on the principle that val is a member of lst if the list is not empty and val is the first element of lst or val is a member of the remainder of lst.

  (define member?
    (lambda (val lst)
      (and (not (null? lst))
           (or (equal? val (car lst))
               (member? val (cdr lst))))))
  

Designing Case Cases

• The biggest problem I see in recursive procedure design is the choice of base case.
• Think carefully about the type of value your procedure returns:
  • If it returns numbers, your base case should be a number.
  • If it returns lists, your base case should be a list (often null).
  • If it returns some other type of value, your base case should be that type of value.
• You should also make sure to have a base case. (Scheme is funny when you don't return a value and then try to use it.)

Lab

• Start working on the list-recursion lab.