Comp 210 Lab 12: Review

Feel free to chat with your lab group about any of the following questions, and ask any questions from any previous labs, homeworks, or exams. Some particular things you might still have questions on:

• On exam 2, how does the waterway problem (#3) follow directly from the design recipe? (And hey, what were the steps of the design recipe again, including all three steps of the standard template? Following them mindfully would have helped many exam scores, and resulted in many more working functions.) For the trick-or-treat problem, why is a list-of-candy a better return value than, say, 'done or true?
• What were those weird interactions between local and set!, from last week's lab? Do they fit the alleged Law of Set! given in class (that set! goes and re-writes a define, so that future placeholder-lookups are affected, but it doesn't re-evaluate anything else).
• What is the scope of a placeholder created through
  1. a top-level define
  2. a lambda parameter
  3. local
• Anything else on previous homeworks, exams, or labs.
• Other new questions you may wonder about:
  1. We went 11 weeks, writing significatn programs, without needing to use set!. Is it possible to write any function, avoiding the use of set!?
  2. If local had not been provided in the language, could we write our code slightly differently, to get most of the bonuses of local (and, what were those bonuses, again?).
  3. We wrote the loop construct fori= in class. How about a loop construct while, which might be used like:

     (define (trick-or-treat)
       (while not-enough-goodies?              ; ending condition
              visit-and-filter-out-yuckies     ; body
              empty))                          ; initial value
     
     
     
     (define (no-final-states? states) (empty? (filter final-state? states)))
     (define (one-trip-later   states) ...)
     
     (while no-final-states?
            one-trip-later
            (list the-start-state))
     

     Hmmm, this is actually addressed in the lecture-notes, even thouth it wasn't discussed in lecture.
  4. Are there actually variants of local called let, let*, letrec?
     According to helpdesk and experiments, how do they differ from each other?
     (For that matter, what's the difference again, between local and shared?) Why does Ian seem to like let* so much, at least he's slipped several times in lecture and used it.