Lecture 5: Methods for self-referential lists

Lecture outline

• Representing lists

• Basic methods

• Sorting

5.1 Representing lists

The following class diagram defines a class hierarchy that represents a list of books in a bookstore:

               +--------------------------------+
               | ILoBook                        |<----------------------+
               +--------------------------------+                       |
               +--------------------------------+                       |
               | int count()                    |                       |
               | double salePrice(int discount) |                       |
               | ILoBook allBefore(int y)       |                       |
               | ILoBook sortByPrice()          |                       |
               +--------------------------------+                       |
                                |                                       |
                               / \                                      |
                               ---                                      |
                                |                                       |
                  -----------------------------                         |
                  |                           |                         |
+--------------------------------+   +--------------------------------+ |
| MtLoBook                       |   | ConsLoBook                     | |
+--------------------------------+   +--------------------------------+ |
+--------------------------------+ +-| Book first                     | |
| int count()                    | | | ILoBook rest                   |-+
| double salePrice(int discount) | | +--------------------------------+
| ILoBook allBefore(int y)       | | | int count()                    |
| ILoBook sortByPrice()          | | | double salePrice(int discount) |
+--------------------------------+ | | ILoBook allBefore(int y)       |
                                   | | ILoBook sortByPrice()          |
                                   | +--------------------------------+
                                   v
                   +--------------------------------+
                   | Book                           |
                   +--------------------------------+
                   | String title                   |
                   | String author                  |
                   | int year                       |
                   | double price                   |
                   +--------------------------------+
                   | double salePrice(int discount) |
                   +--------------------------------+

Let’s make some examples

5.2 Basic list computations

Given this preceding class diagram, we would like to design methods to answer the following questions

• Count how many books we have in this list of books

• Compute the total sale price of all books in this list of books, at a given discount rate

• Given a date (year) and this list of books, produce a list of all books in this list that were published before the given year

• Produce a list of the same books as this list, but sorted by their price

Each of the four questions concerns a list of books, and so we start by designing the appropriate method headers and purpose statements in the interface ILoBook:

We now have to define these methods in both the class MtLoBook and in the class ConsLoBook. (You may find it helpful to recall similar functions in DrRacket. Remember from last lecture the pattern given to us by virtue of Dynamic dispatch: we take each clause of the cond that checked for a particular variant and “move” the right-hand sides of those clauses into the methods defined in the corresponding class, then eliminate the cond altogether.)

The design recipe asks us to make examples. For clarity, we write them in an abbreviated manner, just showing the actual computation and the expected outcome:

and our methods become:

Notice that the values produced by these methods are the base case values we have been in DrRacket for the empty lists. The count for an empty list is zero; the salePrice of no Books is zero as well; and starting with an empty list there are no Books at all, let alone any before a given year.

Note: We will return to the sort method later.

Of course, there will be more work to do in the ConsLoBook class. First, examples!

The design recipe asks us now to derive the template. A template serves as a starting point for any method inside ConsLoBook:

count and salePrice

In the template, this.rest.count() produces the count of all books in the rest of this list — and so the method body in the class ConsLoBook becomes:

In the template, this.rest.salePrice(discount) produces the total sale price of all books in the rest of this list for the given discount — and so the method body in the class ConsLoBook just adds to this value the price of the first book in the list:

Do Now!

Did you notice how similar this method body is to the one above for count? In Fundies 1, we had a terser way of expressing this sort of computation. What kind of operation on lists are we computing here? We will see in Lecture 13: Abstracting over behavior how to improve this code.

allBefore

In the template, this.rest.allBefore(year) produces a list of all books in the rest of this list published before the given date. The only work that remains is to decide whether the first book of this list belongs in the output list, and either add it to the result or not. If only we could determine whether that first Book was published before the given year! (Look carefully at the template: we cannot access this.first.year, because we do not have access to fields of fields.) So we add a method to our wish list, and we will delegate the job of deciding this question to the Book class itself. The method body in the class ConsLoBook becomes:

We’re not quite done; we have a method remaining on our wish list, so we must add to the class Book the method

Exercise

Flesh out the rest of the design of this method, adding examples and tests.

Of course, for all of these methods, we end the design process by making sure all tests run. The actual test methods will be:

5.3 Sorting

The last method to design was defined in the interface ILoBook as:

An empty list is sorted already, so in the class MtLoBook the method becomes:

We do not need to create a new empty list, this one works perfectly well.

We need examples for the more complex cases. We recall our sample data:

and our tests will be:

Next we look at the template that is relevant for this question:

But still we have a problem. We’ve defined insert on ConsLoBook, but in the third line, we write this.rest.insert(b) — and we do not know anything about this.rest except that it’s an ILoBook, and ILoBook says nothing about an insert method!

And now we are finally done!