Functional Problem Solving (CSC 151 2013F) : Labs

# Lab: Objects in Scheme

Summary: In this lab, we consider techniques for building objects, collections of data that support operations on those data.

## Exercises

### Exercise 1: Testing Switches

a. Make a copy of the `make-switch` procedure from the reading.

b. Test the switches created by the `make-switch` procedure. Here are a few possible instructions.

````>` `(define lamp-switch (make-switch))`
`>` `(define vacuum-cleaner-switch (make-switch))`
`>` `(lamp-switch ':get-position)`
`>` `(vacuum-cleaner-switch ':get-position)`
`>` `(lamp-switch ':toggle!)`
`>` `(lamp-switch ':get-position)`
`>` `(vacuum-cleaner-switch ':get-position)`
`>` `(lamp-switch ':toggle!)`
`>` `(vacuum-cleaner-switch ':toggle!)`
`>` `(lamp-switch ':get-position)`
`>` `(vacuum-cleaner-switch ':get-position)`
```

### Exercise 2: A Multi-Stage Switch

As you may know, some switches have more than two positions. For example, we might have a switch that switches between the values 0, 1, 2, and 3. (For a two-way light, 0 might represent “off”, 1 might represent “light one on”, 2 might represent “light two on”, and 3 might represent “both lights on”.) In general, you can only toggle to the next higher value (with 3 returning to 0 when toggled).

Implement a `four-stage-switch` object that responds to the same messages as a switch, but with four possible stages.

### Exercise 3: A Single Tally Object

Define a one-field object, `tally`, that responds to exactly four messages:

• `':get-value`, which returns the value of the tally;
• `':set-contents-to-zero!`, which resets the tally to 0 (that is, the next call to `':get-value` should return 0);
• `':increment!`, which has the effect of increasing the number stored in the `contents` field by 1; and
• `':decrement!`, which has the effect of decreasing the number stored in the `contents` field by 1.

The initial value of the tally should be 0.

Note that you are creating a single object, not a procedure that creates objects.

For example,

````>` `(define tally ...)`
`>` `(tally ':get-value)`
`0`
`>` `(tally ':increment!)`
`>` `(tally ':get-value)`
`1`
`>` `(tally ':decrement!)`
`>` `(tally ':decrement!)`
`>` `(tally ':decrement!)`
`>` `(tally ':get-value)`
`-2`
```

### Exercise 4: Making Generic Tallys

a. Define a `make-tally` procedure that constructs and returns objects similar to the `tally` object you defined in the previous exercise.

b. Create two tally objects and demonstrate that they can be incremented and reset independently.

### Exercise 5: Tallys with Initial Values

Write a new `make-tally` procedure that allows the client to create new tallys with a specied initial value. For example, a professor might say that a starting grade is 90 with

````>` `(define grade (make-tally 90))`
```

The professor would then increment and decrement it as students do good or bad work.

### Exercise 6: Monitored Tallys

a. Define a constructor procedure, `make-monitored-tally`, for objects similar to the `tally` objects from above, except that each such object keeps track of the total number of messages that it has received.

Hint: For this exercise, you may want to make two vectors, one for the value of the tally and one for the count of operations. Alternately, you could make a two-element vector in which element 0 of that vector is the value of the tally and element 1 of that vector is the count of operations.

## For Those with Extra Time

### Extra 1: Parametric Messages

We saw in the reading how to create objects that accept messages with parameters. For instance, turtles need to know how far forward to move. Rather than a tally that requires the user to call it several times to affect a change of greater than one, we may want to change the tally by a certain amount.

Define a constructor procedure, `make-mutable-tally`, for objects similar to the `tally` objects from above, except that each object can take an additional message, `:change-by!` that has the effect of changing the current value of the tally by an argument given to the object.

For example,

````>` `(define mtally (make-mutable-tally))`
`>` `(mtally ':get-value)`
`0`
`>` `(mtally ':increment!)`
`>` `(mtally ':get-value)`
`1`
`>` `(mtally ':change-by! 5)`
`>` `(mtally ':get-value)`
`6`
`>` `(mtally ':change-by! -2)`
`>` `(mtally ':get-value)`
`4`
```

Samuel A. Rebelsky, rebelsky@grinnell.edu

Copyright (c) 2007-2013 Janet Davis, Samuel A. Rebelsky, and Jerod Weinman. (Selected materials are copyright by John David Stone or Henry Walker and are used with permission.)

This work is licensed under a Creative Commons Attribution 3.0 Unported License. To view a copy of this license, visit `http://creativecommons.org/licenses/by-nc/3.0/` or send a letter to Creative Commons, 543 Howard Street, 5th Floor, San Francisco, California, 94105, USA.