Class 30: Local procedure bindings

Held Monday, October 23, 2000

Summary

Today we consider how to define local procedures using letrec and named-let expressions.

Notes

• Today's reading: Local bindings and recursion
• Today's lab: Local bindings and recursion
• I hope to have another reading ready tonight. I'll send out email when/if I do.
• I've delayed grading homework 3 since not all of you turned it in before break. I'll distribute an answer key tomorrow and will not accept any more assignments after I distribute that key.
• I decided to spend much of break in work avoidance mode, so I don't have your homeworks graded yet. The 151 exam is at the top of the stack and the 151 homework is next, so you should have the exam by Wednesday.
• Are there questions on homework 4?

Overview

• Helper procedures, revisited
• Nonrecursive local procedures
• Recursive local procedures with letrec
• Recursive local procedures with named let.

Helper Functions

• We tend to write helper functions.
• Examples:
  • Match likes [Abstract: Recursion within Recursion]
  • Read parts of something [Abstract: Reading and building data]
  • Safe sum [Abstract: Testing preconditions]
• Reminder: We often think of husk and kernel programming. The husk sets things up (e.g., tests preconditions), the kernel does the work.

A Safe Sum

• Here's a precondition testing example.

  ;;; "Safely" sum a list of numbers.
  ;;; Parameters:
  ;;;   A list of numbers.
  ;;; Returns:
  ;;;   The sum of the list.
  ;;; Preconditions:
  ;;;   The list contains only numbers [Verified]
  ;;; Postconditions:
  ;;;   Does not affect the list.
  ;;;   Crashes and burns with a helpful error message if the 
  ;;;     parameter is not a list.
  (define safe-sum
    (lambda (numbers)
      (cond ((not (list? numbers)) 
             (error "safe-sum: given a non-list as a parameter"))
            ((not (all-numbers? numbers))
             (error "safe-sum: given a list that includes non numbers"))
            (else (safe-sum-kernel numbers)))))
  
  ;;; Sum a list of numbers
  ;;; Parameters:
  ;;;   A list of numbers
  ;;; Returns:
  ;;;   The sum of the list
  ;;; Preconditions:
  ;;;   The list contains only numbers [Unverified]
  ;;; Postconditions:
  ;;;   Does not affect the list.
  (define safe-sum-kernel
    (lambda (numbers)
      (if (null? numbers) 0
          (+ (car numbers) (safe-sum-kernel (cdr numbers))))))
  
  ;;; Determine if a list contains only numbers.
  ;;; Parameters:
  ;;;   A list
  ;;; Returns:
  ;;;   #t if the list contains no non-numbers.
  ;;;   #f otherwise
  ;;; Preconditions:
  ;;;   The parameters must be a list [Unverified]
  (define all-numbers?
    (lambda (lst)
      (or (null? lst)
          (and (number? (car lst)) 
               (all-numbers? (cdr lst))))))
  

• What helper procedures are used here?
  • Predefined: and, car, cdr, error, list?, not, null?, and or.
  • User-defined: safe-sum-kernel and all-numbers?
• The accessibility of the two user-defined helper procedures differs.
  • safe-sum-kernel should really be local to safe-sum
  • all-numbers? is more generally useful, and can be globally accessible.

Squaring a List

• Let's consider another example, in which we square all the values in a list of numbers.
• Forthcoming

Making square Local

Making the kernels local

• Crash and burn.

letrec

• Forthcoming

Named let

• Forthcoming

What to do next

When you're done with this outline, see the corresponding reading.