• Continue partners from yesterday.
• Take an index card.

Overview

• Preliminaries.
  • Admin.
  • Upcoming Work.
  • Extra Credit.
  • Questions.
• Review of material from reading
  • Why have local procedures.
  • Creating local procedures with letrec.
  • Creating local procedures with named let.
• An example: Reverse
• Another example: Up/Down Sum
• Remaining questions.
• Lab.

Preliminaries

Admin

• Yes, I do care that you follow the standard "pattern" for the six P's.
  • Three semicolons, one space, the word "Procedure", a colon.
  • Three semicolons, three spaces, the name of the procedure.
  • Three semicolons, one space, the word "Parameters", a colon.
  • Three semicolons, three spaces, the name of the first parameter, a comma, the type of the first parameter
  • Etc.
• I'll probably spend a bit longer talking today because some of this stuff is hard.

Upcoming Work

• Sign up to meet with me if you had difficulty on the exam (or even if you just want to discuss a few more problems or need help interpreting my scrawls).
• Lab writeup: Problem 4, http://bit.ly/151-2014F-w31.
• Reading for Wednesday: Characters and Strings
• Homework 6 (to be assigned on Wednesday), due a week from Tuesday.
• Exam 3, distributed a week from Wednesday, due two weeks from Tuesday.

Extra Credit Opportunities

Academic

• CS Extra Thursday: Randomness in Computer Science.

Peer Support

• Football (Saturday at 1pm)
• Swimming scrimmage noon on Saturday
• Karan's radio show 11pm Thursday nights on KDIC
• Evan's radio show 5pm Friday nights on KDIC
• Donna's radio show Sunday midnight on KDIC
• Sandy's senior showcase play, weekend of week 10, spring 2017

Questions

When is our in class written final: on December 19 at 9:00 AM or 2:00 PM?

From the course home page: "The final examination for this course is optional. It can be used as a makeup for one examination. I will count the final examination only if it is higher than your lowest examination, and it will replace the grade for that examination. Our final examination is scheduled for 9:00 a.m. on Friday, Dec. 19. However, since my other course has a final at 9:00 a.m. on Tuesday, December 16, I can also offer the final then. (If neither time works for you, let's talk. I'll find another time.)"

What is the difference between the husk and kernel?

The husk is the portion of the procedure that checks the preconditions. The kernel is the portion of the procedure that does the real work.

If there's time in class tomorrow, could you explain how the up-sum down-sum recursive procedure works?

Certainly. I've put it at the end of today's topics.

Preparation

The reading covered three main issues.

• Why we want local procedures.
• Local procedure bindings with letrec.
• Local procedure bindings with named let.

Spend two minutes talking about these issues with your partner.

• I'll take volunteers to summarize each of the issues.
• You may also come up with questions that you might like me to address. (The mentors will gather the questions.)

An Example: Three Ways to Reverse a List

Here's the reverse procedure we've written in the past.

(define reverse1
  (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)))))

Here's the same procedure, using letrec. (Why? Because I want to hide the kernel from the outside world, since no one would ever call it, and some people would call it incorrectly.)

(define reverse2
  (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 "define a recursive helper and then call it" pattern is very common, so Scheme includes a special syntax for it.

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

Another Example: Summing Up and Down

> (letrec ([up-sum
            (lambda (ls)
              (if (null? ls)
                  0
                  (+ (car ls) (down-sum (cdr ls)))))]
           [down-sum
            (lambda (ls)
              (if (null? ls)
                  0
                  (+ (- (car ls)) (up-sum (cdr ls)))))])
    (up-sum (list 1 23 6 12 7)))

Motivation:

• We know how to do num + num + num + num ...
• We know how to do num - num - num - num ...
• This one asks us to do num + num - num + num - num + num - num + num ...

Stepping through the procedure:

(up-sum '(1 23 6 12 7)) (+ 1 (down-sum '(23 6 12 7))) (+ 1 (+ -23 (up-sum '(6 12 7)))) (+ 1 (+ -23 (+ 6 (down-sum '(12 7))))) (+ 1 (+ -23 (+ 6 (+ -12 (up-sum '(7)))))) (+ 1 (+ -23 (+ 6 (+ -12 (+ 7 (down-sum '())))))) (+ 1 (+ -23 (+ 6 (+ -12 (+ 7 0)))))

Remaining Questions

Don't seem to be any.

Lab

How do I check if all of the values in a list are irgb colors?

Option one: Work from the code you had yesterday.

    (define all-drawings?
      (lambda (lst)
        (or (null? lst)
            (and (drawing? (car lst))
                 (all-drawings? (cdr lst))))))

Replace drawings with irgb.

    (define all-irgb?
      (lambda (lst)
        (or (null? lst)
            (and (irgb? (car lst))
                 (all-irgb? (cdr lst))))))

Option two: Use the not-yet-documented all procedure.

The form is (all PREDICATE LST).

Example:

    > (all irgb? (list "red" 23))
    #f
    > (all irgb? (list (irgb 212 121 5) (irgb 100 100 100)))
    #t