Class 51: Object Basics

Held Thursday, May 3, 2001

Summary

Today we consider how to make objects that encapsulate values and provide capabilities.

Notes:

• Read Stacks and Abstract Data Types.
• Are there any final questions on homework 6?

Overview

• Extending Objects
• Procedures as Objects
• Adding State
• Lab

Extending Records

• As we've seen in our experiments with records, there are both strengths and weaknesses of our current implementations.
• Strengths: Access parts of a group by name; Relatively easy to use.
• Weaknesses: Not fully encapsulated; hard to separate core operations from external operations (since they're called the same way).
• In the late 1960's, some computer scientists decided to extend the notion of record further into something they called an object
• Objects group data.
• Objects can 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.
• The requests you send to objects are called messages.

Objects in Scheme

• Scheme doesn't include objects as a built-in type. Hence, we have to implement them ourselves.
• The trick 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