Overview

• Preliminaries.
  • Admin.
  • Questions on the Exam.
  • Pre-quiz Questions.
• Two new types!
• Quiz.
• Lab

Admin

• We're trying a slightly different order for today's class.
• Reminder: The optional prologue for the exam is due tonight at 5pm
• Upcoming extra credit opportunities:
  • Any one Grinnell prize event next week [academic]
  • Thursday extras next week: Reports from internships (I think) [academic]
  • Grinnell Town Hall Meeting, Nov 13 noon or 7:30, I believe [academic]
  • Performance for 24 hour composition festival on Saturday 7:30 in S-L. Cheer John's composition. [peer]
  • Intra-team swim meet this weekend [peer]
  • Space exploration Friday. James 1st Lounge at 7pm. [peer]
  • Orchestra, Nov. 9 at 7:30, probably in S-L.
  • Hamlet, Nov. 22-24. [peer]
  • Basketball tournament at Elssworth (Iowa Falls?) [peer]

Exam 2 Questions

• Can we use length for problem 6? No!
• For problem 5, can we use our solution to problem 4? Yes, but I'm not sure why you would.

Pre Quiz Questions

Can you help me with named let? "I need to create a helper with these parameters (p1 p2), and I need to call the helper with values v1 v2." Here's the syntax

(let helper ([p1 v1]
             [p2 v2])
   instructions)

(let helper ([so-far 0]
             [lst lst])

• These are the first values of the parameters. When we do a recursive call, we can change them.
• Does this sometimes look stupid, like when p2 and v2 are the same? Yeah, it can be hard to read. You just have to remember that the lst for v2 means "input to the overall procedure" and the lst for p2 is "input to the helper procedure"

This corresponds to a lambda expression AND A CALL to the lambda

(letrec ([helper (lambda (p1 p2) instructions)]) (helper v1 v2))

A big difference for the named let version is, while you can call it recursively, you can't access the procedure outside the body of the let.

Geometric art had cond expressions without an else.

(cond [(> n 0) (image-draw-line! ...) (kernel ... (- n 1))])

Meaning: If no tests succeed, just do nothing (other than the tests).

We should have used

(when (> n 0) (image-draw-line! ...) (kernel ... (- n 1)))

Can we have a formula for letrec as a kernel

(define PROC (letrec ([kernel (lambda (p1 p2) BODY)]) (lambda (a0 a1) (cond [(fails-precondition? a0 a1) (error "You seem to misunderstand.")] [(fails-another-precondition? a0) (error "Maybe Sam misunderstands.")] [else (kernel a0 a1)]))))

Two new types!

• As you may recall from our initial discussion of algorithms, the things we do with a programming language are affected by the kinds of values the language allows you to work with.

• Types we've seen so far include ...

  • list
  • number, including a variety of subtypes
    • exact integers
    • inexact integers
    • exact complex
    • ...
  • New: character
  • image
  • drawing
  • Newish: string
  • Boolean
  • Color (RGB integers)
  • Not yet: Files
  • Turtles
  • Symbols
  • procedures, including predicates

• Two new types: characters and strings

• What questions do you (or should you) ask yourself when seeing a new type?
  • Why would we have this type? What does it do? For characters and strings: Represents what I'm typing right now
    • What are some sample problems for which this would be useful?
  • How you distinguish it from other types? (char? x) (string? x)
  • What operations are available? (Too many for Sam to enumerate. See the reading. string-=?, number->char char->number, (string ....) (string->list "...")
  • How do we create them?
  • What are the limits on how we use them? No limits! Well, you can't add them, multiply them, ..
  • How do people refer to them?
  • How do I write the values?
    • Strings "asdasdfdf"
      • Backslashes before "
      • Backslashes before \
    • Characters: #\a

Quiz

• What is ǝ?

Lab

Do it on your own. Have a good weekend.