Held: Wednesday, 28 October 2015

Back to Outline 31 - Numeric Recursion. On to Outline 33 - Turtle Graphics.

Summary

We explore why and how one writes local recursive procedures.

Related Pages

• Reading: Local Procedure Bindings
• Lab: Local Procedure Bindings
• EBoard 32 (Source 32)

Overview

• Why have local procedures.
• Creating local procedures with letrec.
• Creating local procedures with named let.

Administrivia

• New partners.
• More stuff before lab today
• Review sessions this week
  • Wednesday 8pm (Caleb)
  • Thursday 10am (SamR)
  • Thursday 8pm (Erin)
• Notes on lab 30 are now available.

Upcoming Work

• Reading for Friday: Turtle Graphics
• Quiz Friday: Recursion, Recursion, and more Recursion
• HW 6 due next Tuesday.
  • May be a few bugs in part A.
• Today's Lab writeup (due before class Monday)
  • Email to grader-151-01@cs.grinnell.edu
  • Subject: CSC 151 Lab Writeup Class 32 (Your Names)
  • Exercises:

Extra Credit Opportunities

• If possible, send me these in advance.

Academic

• Any visit to the current show in the Faulconer gallery.
• Any of the Grinnell Prize Week Activities this week.
• Grinnell Town Hall Wednesday at noon: Self-Gov.
• Conversation about Study Abroad at AIT in Hungary: Wednesday at 4:15 in 3821.
• Convocation Thursday at 11: Contesting Muhammad: Contermporary Controversies in Historical Perspective
• CS Extras Thursday at 4:15pm in 3821: Algorithms for Assembling the Tree of Life.
• What's the Deal with the Digital Liberal Arts? Thursday at 4:15 in the D-Lab. With Autumnal snacks!
• R.L. Stephens II events Thursday and Friday.
• Expressing Yourself Inside and Outside the Classroom: A Faculty Panel. Friday, noon, JRC 209. (With Prof. Katya, SamR, Prof. Praitis, Prof. Willig Onwuachi, and Prof. Byrd)
• CS Table Tuesday: Why people support and bully online.
• Sexual Misconduct at Grinnell College: Results from the 2013 and 2015 Sexual Conduct Surveys. 1-3 pm, November 8, JRC 101.

Peer Support

• Thursday at 7pm, Womens BBall (scrimmage vs MCC)
• Spark Tank, Wednesday, 7pm in Roberts Theatre in Bucksbaum.
• Pals of PALS, pals@grinnell.edu, normally Saturday at 7:45 am (breakfast included), Sunday at 4:45, and Mondays at 4:45. Requires sign up in advance.
• Pun Club, Saturdays, 4pm, Way over Younker.

Upcoming Peer Support

• Women's Basketball Opening Game, 1pm, Nov. 15, vs. Silver Lake.
• One-act Festival Dec. 5 & 6.

Other Good Stuff to Do

• Women's Soccer Saturday
• Men's Soccer Saturday
• Halloween event Saturday

Husk and Kernel Programming

• Particularly for recursive procedures, it is inefficient to check preconditions at every recursive call
  • If the preconditions were met for the first call, they should be met for every subsequent call.
• Hence, programmers tend to use what I refer to as "Iowa's Great Contribution to Programming": The Husk-and-Kernel approach
  • The husk checks the preconditions and, if all preconditions are met, calls the kernel.
  • The kernel does the real work.
• Corn serves as the metaphor: The husk protects the kernel, and the kernel is the valuable part.
  • And no, Husk-and-Kernel programming was not invented in Iowa.

Local Procedure Bindings

• Today's class will focus not on something new, but on a better way to do something old: Define helper procedures.
• We frequently want to define procedures that are only available to certain other procedures (typically to one or two other procedures).
• We call such procedures local procedures
• Most local procedures can be done with let and let*.
• However, neither let nor let* works for recursive procedures.
• When you want to define a recursive local procedure, use letrec.
• When you want to define only one, you can use a variant of let called "named let".

letrec

• A letrec expression has the format

(letrec ([*name1* *exp1*]
         [*name2* *exp2*]
         ...
         [*namen* *expn*])
  *body*)

• A letrec is evaluated using the following series of steps.
  • First, enter *name<sub>1</sub>* through *name<sub>n</sub>* into the binding table. (Note that no corresponding values are entered.)
  • Next, evaluate *exp<sub>1</sub>* through *exp<sub>n</sub>*, giving you results *result<sub>1</sub>* through *result<sub>n</sub>*.
  • Finally, update the binding table (associating *name<sub>i</sub>* and *result<sub>i</sub>* for each reasonable i.
• Not thate its meaning is fairly similar to that of let, except that the order of entry into the binding table is changed.

Named let

• Named let is somewhat stranger, but is handy for some problems.
• Named let has the format

(let *name* 
  ((*param1* *exp1*)
   (*param2* *exp2*)
   ...
   (*paramn* *expn*))
  *body*)

• The meaning is as follows:
  • Create a procedure with formal parameters *param<sub>1</sub>* ... *param<sub>n</sub>* and body *body*.
  • Name that procedure *name*.
  • Call that procedure with actual parameters *exp<sub>1</sub>* through *exp<sub>n</sub>* .
• Yes, that's right, we've packaged together the procedure definition and the procedure call.
• In effect, we're just doing

(letrec ((*name* (lambda (*param1* ...
*paramn
*)
                  *body*)))
   (*name* *val1* ... *valn*))

An Example

• As an example, let's consider the problem of writing reverse.
• A first version, without local procedures

(define reverse
  (lambda (lst)
    (reverse-kernel lst null)))
(define reverse-kernel
  (lambda (remaining so-far)
    (if (null? remaining)
        so-far
        (reverse-kernel (cdr remaining) (cons (car remaining) so-far)))))

The principle of encapsulation suggests that we should make reverse-kernel a local procedure.

(define reverse
  (letrec [(kernel
            (lambda (remaining so-far)
              (if (null? remaining)
                  so-far
                  (kernel (cdr remaining) (cons (car remaining) so-far)))))]
    (lambda (lst)
      (kernel lst null))))

The pattern of "create a kernel and call it" is so common that the named let exists simply as a way to write that more concisely.

(define reverse
  (lambda (lst)
    (let kernel [(remaining lst)
                 (so-far null)]
      (if (null? remaining)
          so-far
          (kernel (cdr remaining) (cons (car remaining) so-far))))))

Lab

• Work on the the lab.