Class 22: Local Bindings

Held Wednesday, February 28, 2001

Summary

Today we consider how to bind names to values using Scheme's let expressions.

Notes

• Are there further questions on exam 1?
  • Yes, the first problem is probably the hardest.
  • Yes, I'll grade you on elegance.
  • Warning: Those of you who receive extensions may find that their exams are not graded until after break.
• There is no reading for tomorrow. I'll provide a short introduction to the topic at the beginning of tomorrow's class and may make an additional reading available if there is confusion on the topic.
• I've updating some formatting on the course web. Let me know if you encounter difficulties.
• Warning! The code in today's outline was sketched and not tested. It may be partially or completely incorrect.

Overview

• Why name things
• Naming things with let
  • Example
• Naming things with let*
• Naming procedures

The Problem: Naming Values

• As we've seen in many problems, it helps to name the values that we use within our procedure. Why?
  • It can make the code more readable because the name tells us something about the role the value plays.
  • It can make the code more efficient, because it allows us to avoid recomputing a value.
• Consider our problem of the modified assoc which returns a list of all of the matching values, if there are any; and #f otherwise.

  (define assoc-all
    (lambda (key database)
      ; Nothing can be in the empty database, so return false.
      (if (null? database) 
          #f
          ; If we match the car of the database, look in the rest.
          (if (equal? key (car (car database)))
              ; If the key does not appear any more in the database
              ; make a list of just the one value we've seen
              (if (not (assoc-all key (cdr database)))
                  (list (car database))
                  ; Otherwise, attach the matched entry to
                  ; the remaining matched entries
                  (cons (car database) (assoc-all key (cdr database))))
              ; We didn't match the car, so just look in the rest
              (assoc-all key (cdr database)))))))
  

• In that code, we potentially call (car database) at least twice in each recursive call and assoc-all twice in some.
• Why are we using the car? Because it's one element in the database. Hence, it would make sense to name it as such.
• Why do we call assoc-all twice? Once to determine if there are any remaining elements and once to use those remaining elements.
• It therefore helps us to name things.

Naming Things with let

• You name things with let.
• let has the form

  (let ((name1 exp1)
        (name2 exp2)
        ...
        (namen expn))
    body)
  

• let has the meaning:
  • Evaluate all the expressions.
  • Update the binding table to associate each name with the corresponding value.
  • Evaluate body using the updated binding table.
  • Eliminate all the bindings just created.
• You can use let in a simple expression:

  (define values (list 1 4 2 4 1 5 9))
  (let ((largest (max values))
        (smallest (min values)))
    (/ (+ largest smallest) 2))
  

• More frequently, we use let within a procedure. Here's a new version of assoc-all that uses let.

  (define assoc-all
    (lambda (key database)
      ; Nothing can be in the empty database, so return false.
      (if (null? database) 
          #f
          ; Otherwise, we need to look more closely.
          (let ((element (car database)) ; Get one element
                (other-matches           ; Find any other matching elements
                 (assoc-all key (cdr database))) )
            ; If the current element matches ...
            (if (equal? key (car (element)))
                ; If it also appears elsewhere, join 'em together.
                (if (other-matches) 
                    (cons element other-matches)
                    ; Otherwise, just make a list of the one value
                    (list (car database)))
                ; If the current element does not match, just look
                ; in the rest.
                (assoc-all key (cdr database)))))))
  

Sequencing Bindings with let*

• If we want to bind some things in sequence, we need to use let* rather than let.
• let* has the form

  (let* ((name1 exp1)
        (name2 exp2)
        ...
        (namen expn))
    body)
  

• let* has the meaning:
  • Evaluate exp1.
  • Update the binding table to associate name1 with that value.
  • Evaluate exp2 in the updated binding table.
  • Update the binding table to associate name2 with that value.
  • ...
  • Evaluate expn in the updated binding table.
  • Update the binding table to associate namen with that value.
  • Evaluate body using the updated binding table.
  • Eliminate all the bindings just created.

• You can also use this technique to name helper procedures. However, it does not work for recursive helper procedures.
• We'll return to recursive helper procedures next week.
• Here's an example of the use of a non-recursive helper procedure that checks whether a value of any type is exact

  ;;; Procedure:
  ;;;   exact-average
  ;;; Parameters:
  ;;;   num1, an exact number
  ;;;   num2, an exact number
  ;;; Purpose:
  ;;;   Average the two numbers.
  ;;; Produces:
  ;;;   average, an exact number
  ;;; Preconditions:
  ;;;   num1 is an exact number [Verified]
  ;;;   num2 is an exact number [Verified]
  ;;; Postconditions:
  ;;;   Guess.
  (define exact-average
    (lambda (num1 num2)
      (let ((verify? 
            (lambda (val) (and (number? val) (exact? val)))))
        (cond
          ((not (verify? num1))
           (error "exact-average" "first parameter is a non-number"))
          ((not (verify? num2))
           (error "exact-average" "second parameter is a non-number"))
          (else (/ (+ num1 num2) 2))))))