Held: Friday, 2 May 2014

Back to Outline 51 - Project Assessment: Algorithms. On to Outline 53 - Objects in Scheme, Continued.

Summary

We begin to explore objects in Scheme. Objects encapsulate data and the procedures that work with those data.

Related Pages

• Reading: Building Objects in Scheme
• Lab: Building Objects in Scheme
• EBoard 52 (Source 52) (HTML 52) (PDF 52)

Overview

• Motivating problems: Circles, turtles, and counters.
• Building and using compound values.
• Objects: A new approach to compound values.
• Creating objects in Scheme.

Administrivia

Upcoming Work

• No more homework.
• Reading for Monday: Review Objects in Scheme
• No lab writeup.

Extra Credit

• Jazz band 7:30-9:30 Friday night in Sebring-Lewis.
• Anyone in GIMP?

Motivating Problems

• Suppose we want to make a drawing composed of a lot of circles. How should we represent the circles?
• How might we implement a counter to keep track of the number of times we do procedure calls?
• How might we implement turtles?

Compound Values

• We've seen two ways to represent such compound values.
  • As a list
  • As a vector
• Once we've chosen a representation, we then build a set of procedures that work with that representation.
• As we've seen in our experiments with representing compound values, there are strengths and weaknesses to simply choosing a representation and writing procedures to work with that implementation.
• Strengths: Access parts by procedure; Relatively easy to use.
• Weaknesses: Not fully encapsulated; hard to separate core operations from external operations (since they're called the same way); hard to limit access.

Objects: Encapsulating Values and Operations

• In the late 1960's, some computer scientists decided to extend the idea of representing data into something they call an object
• Objects group data.
• Objects also do things.
• You can't directly access the parts of an object.
• Rather, you ask the object to do things or tell you things using their internal state.
• The requests you send to objects are called messages.
• Traditional objects also provide a number of other advantages.
  Nonetheless, we'll focus on encapsulation.

Objects in Scheme

• Standard Scheme doesn't include objects as a built-in type. Hence, we have to implement them ourselves.
  • And, even if some newer variants of Scheme, like Racket, include objects, there's a benefit to thinking about how to implement them yourself.
• The approach that we recommend is that you implement objects as procedures that take a message as a parameter.
• Traditionally, the messages begin with a colon.
• Here's a simple object that will respond when you greet it or leave it.

(define greeter
  (lambda (message)
    (cond 
      ((eq? message ':enter) (display "Hello") (newline))
      ((eq? message ':leave) (display "Goodbye") (newline))
      (else (error "Unknown Message")))))

• Here's how we use it

> (greeter ':enter)
Hello
> (greeter ':leave)
Goodbye
> (greeter ':sleep)
Unknown Message

Adding State

• But how do we have an object keep track of information about itself?
• We build a local symbol table that is only accessible to the procedure.
• We can build such a table by putting a let outside the lambda for the procedure.

(define fixed-value
  (let ((value 5))
    (lambda (message)
      (cond
        [(eq? message ':get) value]
        [else (error "fixed-value:" "unknown message")]))))

• Typically, we use vectors to encapsulate our state because we know how to mutate vectors.

(define incrementable-value
  (let ((value (vector 0)))
    (lambda (message)
      (cond
        [(eq? message ':get) 
         (vector-ref value 0)]
        [(eq? message ':add1!)
         (vector-set! value 0 
                      (+ 1 (vector-ref value 0))))
        [else (error "fixed-value:" "unknown message")]))))

• And an example of its use

> (incrementable-value ':get)
0
> (incrementable-value ':add1!)
> (incrementable-value ':get)
1

Lab

• Begin the lab on objects in Scheme.
• Plan to continue that lab next class.