### II` `Arbitrarily Large Data

Every data definition in Fixed-Size Data describes data of a fixed size. To us, boolean values, numbers, strings, and images are atomic; computer scientists say they have a size of one unit. With a structure, you compose a fixed number of pieces of data. Even if you use the language of data definitions to create deeply nested structures, you always know the exact number of atomic pieces of data in any specific instance. Many programming problems, however, deal with an undetermined number of pieces of information that must be processed as one piece of data. For example, one program may have to compute the average of a bunch of numbers and another may have to keep track of an arbitrary number of objects in an interactive game. Regardless, it is impossible with your knowledge to formulate a data definition that can represent this kind of information as data.

This part revises the language of data definitions so that it becomes possible to describe data of (finite but) arbitrary size. For a concrete illustration, the first half of this part deals with lists, a form of data that appears in most modern programming languages. In parallel to the extended language of data definitions, this part also revises the design recipe to cope with such data definitions. The latter chapters demonstrate how these data definitions and the revised design recipe work in a variety of contexts.

### 9` `Lists

This chapter introduces self-referential data definitions, that is, definitions that refer to themselves. It is highly unlikely that you have encountered such definitions before. Your English teachers certainly stay away from these, and many mathematics courses are somewhat vague when it comes to such definitions. Programmers cannot afford to be vague; programming languages call for precise definitions.

Lists are one ubiquitous instance of self-referential data definitions. With lists, our programming examples become interesting, which is why this chapter introduces them and shows some ways of manipulating them. It thus motivates the revision of the design recipe in the next chapter, which explains how to systematically create functions that deal with self-referential data definitions.

#### 9.1` `Creating Lists

All of us make lists all the time. Before we go grocery shopping, we write down a list of items we wish to purchase. Some people write down a to-do list every morning. During December, many children prepare Christmas wish lists. To plan a party, we make a list of invitees. Arranging information in the form of lists is a ubiquitous part of our life.

Given that information comes in the shape of lists, we must clearly learn how to represent such lists as BSL data. Indeed, because lists are so important BSL comes with built-in support for creating and manipulating lists, similar to the support for Cartesian points (posn). In contrast to points, the data definition for lists is always left to you. But first things first. We start with the creation of lists.

'()

(cons "Mercury" '())

list

diagram

(cons "Mercury" '())

(cons "Venus" (cons "Mercury" '()))

(cons "Earth" (cons "Venus" (cons "Mercury" '())))

(cons "Earth" (cons "Venus" (cons "Mercury" '())))

Because even good artists would have problems with drawing deeply nested structures, computer scientists resort to box-and-arrow diagrams instead. Figure 33 illustrates how to re-arrange the last row of figure 32. Each cons structure becomes a separate box. If the rest field is too complex to be drawn inside of the box, we draw a bullet instead and a line with an arrow to the box that it contains. Depending on how the boxes are arranged you get two kinds of diagrams. The first, displayed in the top row of figure 33, lists the boxes in the order in which they are created. The second, displayed in the bottom row, lists the boxes in the order in which they are consed together. Hence the second diagram immediately tells you what first would produced when applied to the list, no matter how long the list is. For this reason, people tend to prefer the second arrangement.

a list of celestial bodies, say, at least all the planets in our solar system;

a list of items for a meal, for example, steak, French fries, beans, bread, water, brie cheese, and ice cream; and

a list of colors.

; A 3LON is (cons Number (cons Number (cons Number '()))) ; interpretation (cons 1 (cons -1 (cons -2 '()))) represents a point ; in a three-dimensional space

; A List-of-names is one of: ; – '() ; – (cons String List-of-names) ; interpretation a List-of-names represents a list of invitees by last name

(cons "Findler" '())

Exercise 124. Create an element of List-of-names that contains five Strings. Sketch a box representation of the list similar to those found in figure 32.

Explain why

Now that we know why our first self-referential data definition makes sense, let us take another look at the definition itself. Looking back we see that all the original examples in this section fall into one of two categories: start with an '() list or use cons to add something to an existing list. The trick then is to say what kind of “existing lists” you wish to allow, and a self-referential definition ensures that you are not restricted to lists of some fixed length.

Exercise 125. Provide a data definition for representing lists of Boolean values. The class contains all arbitrarily long lists of Booleans.

#### 9.2` `What Is '(), What Is cons

Let us step back for a moment and take a close look at '() and cons. As mentioned, '() is just a constant. When compared to constants such as 5 or "this is a string", it looks more like a function name or a variable; but when compared with #true and #false, it should be easy to see that it really is just BSL’s representation for empty lists.

> (empty? '()) #true

> (empty? 5) #false

> (empty? "hello world") #false

> (empty? (cons 1 '())) #false

> (empty? (make-posn 0 0)) #false

(define-struct pair [left right]) ; A ConsPair is (make-pair Any Any). ; Any Any -> ConsPair (define (our-cons a-value a-list) (make-pair a-value a-list))

> (cons 1 2) cons: second argument must be a list, but received 1 and 2

; A ConsOrEmpty is one of: ; – '() ; – (cons Any ConsOrEmpty) ; interpretation ConsOrEmpty is the class of all BSL lists ; Any ConsOrEmpty -> ConsOrEmpty (define (our-cons a-value a-list) (cond [(empty? a-list) (make-pair a-value a-list)] [(our-cons? a-list) (make-pair a-value a-list)] [else (error "cons: list as second argument expected")]))

; ConsOrEmpty -> Any ; extracts the left part of the given pair (define (our-first a-list) (if (empty? a-list) (error 'our-first "...") (pair-left a-list)))

If your program can access the structure type definition for pair, it is easy to create pairs that don’t contain '() or another pair in the right field. Whether such bad instances are created intentionally or accidentally, they tend to break functions and programs in strange ways. BSL therefore hides the actual structure type definition for cons to avoid these problems. Local Function Definitions demonstrates one way how your programs can hide such definitions, too, but for now, you don’t need this power.

'()

a special value, mostly to represent the empty list

a predicate to recognize '() and nothing else

a checked constructor to create two-field instances

the selector to extract the last item added

the selector to extract the extended list

a predicate to recognizes instances of cons

Figure 34 summarizes this section. The key insight is that '() is a unique value and that cons is a checked constructor that produces list values. Furthermore, first, rest, and cons? are merely distinct names for the usual predicate and selectors. What this chapter teaches then is not a new way of creating data but a new way of formulating data definitions.

#### 9.3` `Programming with Lists

Here we use the word “friend” in the sense of social networks, not the real world.

Sample Problem: You are working on the contact list for some new cell phone. The phone’s owner updates—

adds and deletes names— and consults this list— looks for specific names— on various occasions. For now, you are assigned the task of designing a function that consumes this list of contacts and determines whether it contains the name “Flatt.”

; List-of-names -> Boolean ; determines whether "Flatt" occurs on a-list-of-names (define (contains-flatt? a-list-of-names) #false)

(check-expect (contains-flatt? '()) #false)

(check-expect (contains-flatt? (cons "Findler" '())) #false) (check-expect (contains-flatt? (cons "Flatt" '())) #true)

(check-expect (contains-flatt? (cons "Mur" (cons "Fish" (cons "Find" '())))) #false) (check-expect (contains-flatt? (cons "A" (cons "Flatt" (cons "C" '())))) #true)

Take a breath. Run the program. The header is a “dummy” definition for the function; you have some examples; they have been turned into tests; and best of all, some of them actually succeed. They succeed for the wrong reason but succeed they do. If things make sense now, read on.

(define (contains-flatt? a-list-of-names) (cond [(empty? a-list-of-names) ...] [(cons? a-list-of-names) ...]))

(define (contains-flatt? a-list-of-names) (cond [(empty? a-list-of-names) ...] [(cons? a-list-of-names) (... (first a-list-of-names) ... (rest a-list-of-names) ...)]))

(define (contains-flatt? a-list-of-names) (cond [(empty? a-list-of-names) #false] [(cons? a-list-of-names) (... (string=? (first a-list-of-names) "Flatt") ... ... (rest a-list-of-names) ...)]))

Fortunately, we have just such a function: contains-flatt?, which according to its purpose statement determines whether a list contains "Flatt". The purpose statement implies that if l is a list of strings, (contains-flatt? l) tells us whether l contains the string "Flatt". Similarly, (contains-flatt? (rest l)) determines whether the rest of l contains "Flatt". And in the same vein, (contains-flatt? (rest a-list-of-names)) determines whether or not "Flatt" is in (rest a-list-of-names), which is precisely what we need to know now.

; List-of-names -> Boolean (define (contains-flatt? a-list-of-names) (cond [(empty? a-list-of-names) #false] [(cons? a-list-of-names) (... (string=? (first a-list-of-names) "Flatt") ... ... (contains-flatt? (rest a-list-of-names)) ...)]))

; List-of-names -> Boolean ; determines whether "Flatt" occurs on a-list-of-names (check-expect (contains-flatt? (cons "Mur" (cons "Fish" (cons "Find" '())))) #false) (check-expect (contains-flatt? (cons "A" (cons "Flatt" (cons "C" '())))) #true) (define (contains-flatt? a-list-of-names) (cond [(empty? a-list-of-names) #false] [(cons? a-list-of-names) (or (string=? (first a-list-of-names) "Flatt") (contains-flatt? (rest a-list-of-names)))]))

Here then is the complete definition: figure 35. Overall it doesn’t look too different from the definitions in the first chapter of the book. It consists of a signature, a purpose statement, two examples, and a definition. The only way in which this function definition differs from anything you have seen before is the self-reference, that is, the reference to contains-flatt? in the body of the define. Then again, the data definition is self-referential, too, so in some sense this second self-reference shouldn’t be too surprising.

(cons "Fagan" (cons "Findler" (cons "Fisler" (cons "Flanagan" (cons "Flatt" (cons "Felleisen" (cons "Friedman" '()))))))) What answer do you expect?

Exercise 128. Develop the function contains?, which determines whether some given string occurs on a list of strings.

Note BSL actually comes with member?, a function that consumes two values and checks whether the first occurs in the second, which must be a list:Don’t use member? to define the contains? function.

#### 9.4` `Computing with Lists

== (cond [(empty? (cons "Flatt" (cons "C" '()))) #false] [(cons? (cons "Flatt" (cons "C" '()))) (or (string=? (cons "Flatt" (cons "C" '())) "Flatt") (contains-flatt? (rest (cons "Flatt" (cons "C" '())))))])

== (cond [#false #false] [(cons? (cons "Flatt" (cons "C" '()))) (or (string=? (cons "Flatt" (cons "C" '())) "Flatt") (contains-flatt? (rest (cons "Flatt" (cons "C" '())))))]) == (cond [(cons? (cons "Flatt" (cons "C" '()))) (or (string=? (cons "Flatt" (cons "C" '())) "Flatt") (contains-flatt? (rest (cons "Flatt" (cons "C" '())))))]) == (cond [#true (or (string=? (first (cons "Flatt" (cons "C" '()))) "Flatt") (contains-flatt? (rest (cons "Flatt" (cons "C" '())))))]) == (or (string=? (first (cons "Flatt" (cons "C" '()))) "Flatt") (contains-flatt? (rest (cons "Flatt" (cons "C" '())))))

== (or (string=? "Flatt" "Flatt") (contains-flatt? (rest (cons "Flatt" (cons "C" '()))))) == (or #true (contains-flatt? (rest (cons "Flatt" (cons "C" '()))))) == #true

Also use the stepper to determine the value ofWhat happens when "Flatt" is replaced with "B"?

(our-first (our-cons "a" '())) == "a" (our-rest (our-cons "a" '())) == "a" See What Is '(), What Is cons for the definitions of these functions.

### 10` `Designing with Self-Referential Data Definitions

At first glance, self-referential data definitions seem to be far more complex than those for compound or mixed data. But, as the example of contains-flatt? shows, the six steps of the design recipe still work. Nevertheless, in this section we discuss a new design recipe that works better for self-referential data definitions. As implied by the preceding section, the new recipe generalizes those for compound and mixed data. The new parts concern the process of discovering when a self-referential data definition is needed, deriving a template, and defining the function body:

If a problem statement discusses compound information of arbitrary size, you need a self-referential data definition. At this point, you have seen only one such class, List-of-names, but it is easy to see that it defines the collection of lists of strings, and it is also easy to imagine lists of numbers, etc.

Numbers also seem to be arbitrarily large. For inexact numbers, this is an illusion. For precise integers, this is indeed the case. Dealing with integers is therefore a part of this chapter.

For a self-referential data definition to be valid, it must satisfy two conditions. First, it must contain at least two clauses. Second, at least one of the clauses must not refer back to the class of data that is being defined. It is therefore good practice to identify the self-references explicitly with arrows from the references in the data definition back to its beginning.

You can, and should, also check the validity of self-referential data definitions with the creation of examples. If it is impossible to generate examples from the data definition, it is invalid. If you can generate examples but you can’t see how to generate larger and larger examples, the definition may not live up to its interpretation.

Nothing changes about the header material. You still need a signature, a purpose statement, and a dummy definition. When you do formulate the purpose statement, it is as important as always to keep in mind that it should specify what the function computes not how it goes about it, especially not how it goes through instances of the given data.

Be sure to work through input examples that use the self-referential clause of the data definition several times. It is the best way to formulate tests that cover the entire function definition later.

At the core, a self-referential data definition looks like a data definition for mixed data. The development of the template can therefore proceed according to the recipe in Itemizations and Structures. Specifically, we formulate a cond expression with as many cond clauses as there are clauses in the data definition, match each recognizing condition to the corresponding clause in the data definition, and write down appropriate selector expressions in all cond lines that process compound values.

Question

Answer

Does the data definition distinguish among different subclasses of data?

Your template needs as many cond clauses as subclasses that the data definition distinguishes.

How do the subclasses differ from each other?

Use the differences to formulate a condition per clause.

Do any of the clauses deal with structured values?

If so, add appropriate selector expressions to the clause.

Does the data definition use self-references?

Formulate “natural recursions” for the template to represent the self-references of the data definition.

If the data definition refers to some other data definition, where is this cross-reference to another data definition?

Specialize the template for the other data definition. Refer to this template. See Designing with Itemizations, Again, steps 4 and 5 of the design recipe.

Figure 37: How to translate a data definition into a template

Figure 37 expresses this idea as a “question and answer” game. In the left column it states questions you need to ask about the data definition for the argument, and in the right column it explains what the answer means for the construction of the template. If you ignore the last row and apply the first three questions to any function that consumes a List-of-strings, you arrive at this shape:(define (fun-for-los alos) (cond [(empty? alos) ...] [else (... (first alos) ... (rest alos) ...)])) Recall, though, that the purpose of a template is to express the data definition as a program layout. That is, a template expresses as code what the data definition for the input expresses as a mix of English and BSL. Hence all important pieces of the data definition must find a counterpart in the template, and this guideline should also hold when a data definition is self-referential. In particular, when a data definition is self-referential in the ith clause and the kth field of the structure mentioned there, the template should be self-referential in the ith cond clause and the selector expression for the kth field. For each such selector expression, add an arrow back to the function parameter. At the end, your template must have as many arrows as we have in the data definition.

Since programming languages are text-oriented, you must learn to use an alternative to arrows, namely, self-applications of the function to the selector expression(s):(define (fun-for-los alos) (cond [(empty? alos) ...] [else (... (first alos) ... ... (fun-for-los (rest alos)) ...)])) We refer to a self-use of a function as recursion and in the context of a template as a natural recursion. The last row in figure 37 addresses the issue of “arrows” in data definitions; some of the following chapters will expand on this idea.For the design of the body we start with thoseFor the curious among our readers, the design recipe for arbitrarily large data corresponds to so-called “proofs by induction” in mathematics and the “leap of faith” represents the assumption of the induction hypothesis for the inductive step of such a proof. Courses on logic prove the validity of this proof technique with a so-called Induction Theorem. cond lines that do not contain natural recursions. They are called base cases.The corresponding answers are typically easy to formulate or are already given by the examples.

Then we deal with the self-referential cases. We start by reminding ourselves what each of the expressions in the template line computes. For the natural recursion we assume that the function already works as specified in our purpose statement. This last step is a leap of faith, but as you will see, it always works.

The rest is then a matter of combining the various values.

Question

Answer

What are the answers for the non-recursive cond clauses?

The examples should tell you which values you need here. If not, formulate appropriate examples and tests.

What do the selector expressions in the recursive clauses compute?

The data definitions tell you what kind of data these expressions extract and the interpretations of the data definitions tell you what this data represents.

What do the natural recursions compute?

Use the purpose statement of the function to determine what the value of the recursion means not how it computes this answer. If the purpose statement doesn’t tell you the answer, improve the purpose statement.

How can the function combine these values to get the desired answer?

Find a function in BSL that combines the values. Or, if that doesn’t work, make a wish for a helper function. For many functions, this last step is straightforward. The purpose, the examples, and the template together tell you what the “combiner” function is.

So, if you are stuck here, ...

... arrange the examples from the third step in a table. Place the given input in the first column and the desired output in the last column. In the intermediate columns enter the values of the selector expressions and the natural recursion(s). Add examples until you see a pattern emerge that suggests a “combinator.”

If the template refers to some other template, what does the auxiliary function compute?

Consult the other function’s purpose statement and examples to determine what it computes and assume you may use the result even if you haven’t finished the design of this helper function.

Figure 39: How to turn a template into a function definition

Figure 39 formulates questions and answers for this step. Let us use them for the definition of how-many, a function that determines how many strings are on a list of strings. Assuming we have followed the design recipe, we have the following:

; List-of-strings -> Number ; determines how many strings are on alos (define (how-many alos) (cond [(empty? alos) ...] [else (... (first alos) ... (how-many (rest alos)) ...)])) The answer for the base case is 0 because the empty list contains nothing. The two expressions in the second clause compute the first item and the number of strings on the (rest alos). To compute how many strings there are on all of alos, we just need to add 1 to the value of the latter expression:This example illustrates that not all selector expressions in the template are necessarily relevant for the function definition. In contrast, for the motivating example of the preceding section—contains-flatt?— we use both expressions from the template. In many cases, the combination step can be expressed with BSL’s primitives, for example, +, and, or cons; in some cases, though, you may have to make wishes. See wish lists in Fixed-Size Data. Finally, keep in mind that for some functions, you may need nested conditions.

Last but not least, make sure all the examples are turned into tests, that the tests are run, and that running them covers all the pieces of the function.

Figure 40 summarizes the design recipe of this section in a tabular format. The first column names the steps of the design recipe, the second the expected results of each step. In the third column, we describe the activities that get you there. The figure is tailored to the kind of self-referential list definitions we use in this chapter. As always, practice helps you master the process, so we strongly recommend that you tackle the following exercises, which ask you to apply the recipe to several kinds of examples.

You may want to copy figure 40 onto one side of an index card and write down your favorite versions of the questions and answers in figure 37 and figure 39 onto the back of it. Then carry it with you for future reference. Sooner or later, the design steps become second nature and you won’t think about them anymore. Until then, refer to your index card whenever you are stuck with the design of a function.

steps

outcome

activity

problem analysis

data definition

identify the information that must be represented; develop a data representation; know how to create data for a specific item of information and how to interpret a piece of data as information; identify self-references in the data definition

header

signature; purpose statement; dummy definition

write down a signature, using the names from the data definitions; formulate a concise purpose statement; create a dummy function that produces a constant value from the specified range

examples

examples and tests

work through several examples, at least one per clause in the (self-referential) data definition; turn them into check-expect tests

template

function template

translate the data definition into a template: one cond clauses per clause; one condition per clause to distinguish the cases; selector expressions per clause if the condition identifies a structure; one natural recursion per self-reference in the data definition

definition

full-fledged definition

find a function that combines the values of the expressions in the cond clauses into the expected answer

test

validated tests

run the tests and validate that they all pass

#### 10.1` `Finger Exercises: Lists

Exercise 131. Compare the template for how-many and contains-flatt?. Ignoring the function name, they are the same. Explain why.

; A List-of-amounts is one of: ; – '() ; – (cons PositiveNumber List-of-amounts) ; interpretation a List-of-amounts represents some amounts of money Create some examples to make sure you understand the data definition. Also add an arrow for the self-reference.Design the sum function, which consumes a List-of-amounts and computes the sum of the amounts. Use DrRacket’s stepper to see how (sum l) works for a short list l in List-of-amounts.

; A List-of-numbers is one of: ; – '() ; – (cons Number List-of-numbers) Some elements of this class of data are appropriate inputs for sum from exercise 132 and some aren’t.Design the function pos?, which consumes a List-of-numbers and determines whether all numbers are positive numbers. In other words, if (pos? l) yields #true, then l is an element of List-of-amounts. Use DrRacket’s stepper to understand how pos? works for (cons 5 '()) and (cons -1 '()).

Also design checked-sum. The function consumes a List-of-numbers. It produces their sum if the input also belongs to List-of-amounts; otherwise it signals an error. Hint Recall to use check-error.

What does sum compute for an element of List-of-numbers?

all-true, which consumes a list of Boolean values and determines whether all of them are #true. In other words, if there is any #false on the list, the function produces #false; otherwise it produces #true.

one-true, which consumes a list of Boolean values and determines whether at least one item on the list is #true.

Follow the design recipe: start with a data definition for lists of Boolean values and don’t forget to make up examples.Use DrRacket’s stepper to see how these functions process the lists (cons #true '()), (cons #false '()), and (cons #true #false).

Exercise 135. Design the function cat, which consumes a list of strings and appends them all into one long string. Use DrRackets stepper to evaluate (cat (cons "a" '())).

Exercise 136. Design ill-sized?. The function consumes a list of images loi and a positive number n. It produces the first image on loi that is not an n by n square; if it cannot find such an image, it produces #false.

#### 10.2` `Non-empty Lists

Now you know enough to use cons and to create data definitions for lists. If you solved (some of) the exercises at the end of the preceding section, you can deal with lists of various flavors of numbers, lists of Boolean values, lists of images, and so on. In this section we continue to explore what lists are and how to process them.

; A List-of-temperatures is one of: ; – '() ; – (cons CTemperature List-of-temperatures) ; A CTemperature is a Number greater or equal to -273.

; List-of-temperatures -> Number ; computes the average temperature (define (average alot) 0)

(check-expect (average (cons 1 (cons 2 (cons 3 '())))) 2)

(define (average alot) (cond [(empty? alot) ...] [(cons? alot) (... (first alot) ... (average (rest alot)) ...)]))

The problem is that it was too difficult to turn this template into a working function definition. The first cond clause needs a number that represents the average of an empty collection of temperatures, but there is no such number. Even if we ignore this problem for a moment, the second clause demands a function that combines a temperature and an average for many other temperatures into another average. Although it is isn’t impossible to compute this average, it is not the most appropriate way to do so.

; List-of-temperatures -> Number ; computes the average temperature (define (average alot) (/ (sum alot) (how-many alot))) ; List-of-temperatures -> Number ; adds up the temperatures on the given list (define (sum alot) 0) ; List-of-temperatures -> Number ; counts the temperatures on the given list (define (how-many alot) 0)

; List-of-temperatures -> Number ; adds up the temperatures on the given list (define (sum alot) (cond [(empty? alot) 0] [else (+ (first alot) (sum (rest alot)))]))

When you read this definition of average now, it is obviously correct simply because it directly corresponds to what everyone learns about averaging in school. Still, programs run not just for us but for others. In particular, others should be able to read the signature and use the function and expect an informative answer. But, our definition of average does not work for empty lists of temperatures.

Exercise 137. Determine how average behaves in DrRacket when applied to the empty list of temperatures. Then design checked-average, a function that produces an informative error message when it is applied to '().

From a theoretical perspective, exercise 137 shows that average is a partial function because it raises an error for '(). The alternative development explains that, in this case, we can narrow down the domain and create a total function.

; A NEList-of-temperatures is one of: ; – ??? ; – (cons CTemperature NEList-of-temperatures)

; A NEList-of-temperatures is one of: ; – (cons CTemperature '()) ; – (cons CTemperature NEList-of-temperatures) ; interpretation non-empty lists of measured temperatures

(cons ccc '())

(cons 1 (cons 2 (cons 3 '()))) fits the bill if (cons 2 (cons 3 '())) does;

and (cons 2 (cons 3 '())) belongs to NEList-of-temperatures because (cons 3 '()) is an element of NEList-of-temperatures, as confirmed before.

; NEList-of-temperatures -> Number ; computes the average temperature (check-expect (average (cons 1 (cons 2 (cons 3 '())))) 2) (define (average anelot) (/ (sum anelot) (how-many anelot)))

Exercise 138. Would sum and how-many work for NEList-of-temperatures even if they were designed for inputs from List-of-temperatures? If you think they don’t work, provide counter-examples. If you think they would, explain why.

; NEList-of-temperatures -> Number ; computes the sum of the given temperatures (check-expect (sum (cons 1 (cons 2 (cons 3 '())))) 6) (define (sum anelot) 0)

; NEList-of-temperatures -> Number (define (sum anelot) (cond [(empty? (rest anelot)) ...] [(cons? (rest anelot)) ...]))

(define (sum anelot) (cond [(empty? (rest anelot)) (... (first anelot) ...)] [(cons? (rest anelot)) (... (first anelot) ... (rest anelot) ...)]))

(define (sum anelot) (cond [(empty? (rest anelot)) (... (first anelot) ...)] [(cons? (rest anelot)) (... (first anelot) ... (sum (rest anelot)) ...)]))

(define (sum anelot) (cond [(empty? (rest anelot)) (first anelot)] [(cons? (rest anelot)) (... (first anelot) ... (sum (rest anelot)) ...)]))

(define (sum anelot) (cond [(empty? (rest anelot)) (first anelot)] [(cons? (rest anelot)) (+ (first anelot) (sum (rest anelot)))]))

Exercise 139. Design sorted>?. The function consumes a NEList-of-temperatures. It produces #true if the temperatures are sorted in descending order, that is, if the second is smaller than the first, the third smaller than the second, and so on. Otherwise it produces #false.

Exercise 140. Design how-many for NEList-of-temperatures. Doing so completes average, so ensure that average passes all of its tests, too.

Exercise 141. Develop a data definition for NEList-of-Booleans, a representation of non-empty lists of Boolean values. Then re-design the functions all-true and one-true from exercise 134.

Exercise 142. Compare the function definitions from this section (sum, how-many, all-true, one-true) with the corresponding function definitions from the preceding sections. Is it better to work with data definitions that accommodate empty lists as opposed to definitions for non-empty lists? Why? Why not?

#### 10.3` `Natural Numbers

> (make-list 2 "hello") (cons "hello" (cons "hello" '()))

> (make-list 3 #true) (cons #true (cons #true (cons #true '())))

> (make-list 0 17) '()

; A N is one of: ; – 0 ; – (add1 N) ; interpretation represents the natural numbers or counting numbers

Let us take a close look at the data definition of natural numbers. The first clause says that 0 is a natural number; it is of course used to say that there is no object to be counted. The second clause tells you that if n is a natural number, then n+1 is one too, because add1 is a function that adds 1 to whatever number it is given. We could write this second clause as (+ n 1) but the use of add1 is supposed to signal that this addition is special.

What is special about this use of add1 is that it acts more like a constructor from some structure type definition than a regular numeric function. For that reason, BSL also comes with the function sub1, which is the “selector” corresponding to add1. Given any natural number m not equal to 0, you can use sub1 to find out the number that went into the construction of m. Put differently, add1 is like cons and sub1 is like first and rest.

At this point you may wonder what the predicates are that distinguish 0 from those natural numbers that are not 0. There are two, just as for lists: zero?, which determines whether some given number is 0, and positive?, which determines whether some number is larger than 0.

; N String -> List-of-strings ; creates a list of n strings s (check-expect (copier 2 "hello") (cons "hello" (cons "hello" '()))) (check-expect (copier 0 "hello") '()) (define (copier n s) '())

; N String -> List-of-strings ; creates a list of n strings s (check-expect (copier 2 "hello") (cons "hello" (cons "hello" '()))) (check-expect (copier 0 "hello") '()) (define (copier n s) (cond [(zero? n) '()] [(positive? n) (cons s (copier (sub1 n) s))]))

At this point, you should run the tests to ensure that this function works at least for the two worked examples. In addition, you may wish to use the function on some additional inputs.

Exercise 143. Does copier function properly when you apply it to a natural number and a Boolean or an image? Or do you have to design another function? Read Similarities Everywhere for an answer.

An alternative definition of copier might use else for the second condition:How do copier and copier.v2 behave when you apply them to 0.1 and "xyz"? Explain. Use DrRacket’s stepper to confirm your explanation.

Exercise 144. Design the function add-to-pi. It consumes a natural number n and adds it to pi without using + from BSL. Here is a start:

; N -> Number ; computes (+ n pi) without using + (check-within (add-to-pi 3) (+ 3 pi) 0.001) (define (add-to-pi n) pi) Once you have a complete definition, generalize the function to add, which adds a natural number n to some arbitrary number x without using +. Why does the skeleton use check-within?

Exercise 145. Design the function multiply. It consumes a natural number n and multiplies it with some arbitrary number x without using *.

Use DrRacket’s stepper to evaluate (multiply 3 x) for any x you like. How does multiply relate to what you know from grade school.

Exercise 146. Design two functions: col and row.

The function col consumes a natural number n and an image i. It produces a column—

a vertical arrangement— of n copies of i. The function row consumes a natural number n and an image i. It produces a row—

a horizontal arrangement— of n copies of i Use the two functions to create a rectangle of 8 by 18 squares, each of which has size 10 by 10.

Exercise 147. Design a program that visualizes a 1968-style European student riot. A small group of students meets to make paint-filled balloons, enters some lecture hall and randomly throws the balloons at the attendees.

The program’s only input should be a natural number, which represents the number of balloons. The program should produce an image that contains a black grid, which represents the seats, and the positions of the balls:

You may wish to re-use the functions from exercise 146.

#### 10.4` `Russian Dolls

The problem may strike you as somewhat abstract or even absurd; after all it isn’t clear why you would want to represent Russian dolls or what you would do with such a representation. Suspend your disbelief and read along; it is a worthwhile exercise.

Now consider the problem of representing such Russian dolls with BSL data. With a little bit of imagination, it is easy to see that an artist can create a nest of Russian dolls that consists of an arbitrary number of dolls. After all, it is always possible to wrap another layer around some given Russian doll. Then again, you also know that deep inside there is a solid doll without anything inside.

For each layer of a Russian doll, we could care about many different things: its size, though it is related to the nesting level; its color; the image that is painted on the surface; and so on. Here we just pick one, namely the color of the doll, which we represent with a string. Given that, we know that each layer of the Russian doll has two properties: its color and the doll that is inside. To represent pieces of information with two properties, we always define a structure type:

(define-struct layer [color doll])

(make-layer "green" "red")

(make-layer "yellow" (make-layer "green" "red"))

(make-layer "pink" (make-layer "black" "white"))

; RD -> Number ; how many dolls are a part of an-rd (define (depth an-rd) (cond [(string? an-rd) ...] [(layer? an-rd) (... (layer-color an-rd) ... (depth (layer-doll an-rd)) ...)]))

(layer-color an-rd) extracts the string that describes the color of the current layer;

(layer-doll an-rd) extracts the doll contained within the current layer; and

according to the purpose statement, (depth (layer-doll an-rd)) determines how many dolls (layer-doll an-rd) consists of.

; RD -> Number ; how many dolls are a part of an-rd (define (depth an-rd) (cond [(string? an-rd) 1] [(layer? an-rd) (+ (depth (layer-doll an-rd)) 1)]))

(check-expect (depth (make-layer "yellow" (make-layer "green" "red"))) 3) (check-expect (depth "red") 1)

Exercise 148. Design the function colors. It consumes a Russian doll and produces a string of all colors, separate by a comma and a space. Thus our example should produce"yellow, green, red"

Exercise 149. Design the function inner, which consumes an RD and produces the (color of the) innermost doll. Use DrRacket’s stepper to evaluate (inner rd) for you favorite rd.

#### 10.5` `Lists and World

Sample Problem: Design a world program that simulates firing shots. Every time the “player” hits the space bar, the program adds a shot to the bottom of the canvas. These shots rise vertically at the rate of one pixel per tick.

; physical constants (define HEIGHT 80) (define WIDTH 100) (define XSHOTS (/ WIDTH 2)) ; graphical constants (define BACKGROUND (empty-scene WIDTH HEIGHT)) (define SHOT (triangle 3 "solid" "red"))

; A List-of-shots is one of: ; – '() ; – (cons Shot List-of-shots) ; interpretation the collection of shots fired and moving straight up

; A ShotWorld is List-of-numbers. ; interpretation each number represents the y coordinate of a shot

(check-expect (to-image (cons 10 '())) (place-image SHOT XSHOTS 10 BACKGROUND))

; ShotWorld -> Image (define (to-image w) (cond [(empty? w) ...] [else ... (first w) ... (to-image (rest w)) ...]))

(place-image SHOT XSHOTS (first w) (to-image (rest w)))

; physical constants (define HEIGHT 80) (define WIDTH 100) (define XSHOTS (/ WIDTH 2)) ; graphical constants (define BACKGROUND (empty-scene WIDTH HEIGHT)) (define SHOT (triangle 3 "solid" "red")) ; A ShotWorld is List-of-numbers. ; interpretation the collection of shots fired and moving straight up ; ShotWorld -> ShotWorld (define (main w0) (big-bang w0 (on-tick tock) (on-key keyh) (to-draw to-image))) ; ShotWorld -> ShotWorld ; moves each shot up by one pixel (define (tock w) (cond [(empty? w) '()] [else (cons (sub1 (first w)) (tock (rest w)))])) ; ShotWorld KeyEvent -> ShotWorld ; adds a shot to the world if the space bar was hit (define (keyh w ke) (cond [(key=? ke " ") (cons HEIGHT w)] [else w])) ; ShotWorld -> Image ; adds each y on w at (MID,y) to the background image (define (to-image w) (cond [(empty? w) BACKGROUND] [else (place-image SHOT XSHOTS (first w) (to-image (rest w)))]))

Figure 42 displays the complete function definition for to-image and indeed the rest of the program, too. The design of tock is just like the design of to-image and you should work through it for yourself. The signature of the keyh handler, though, poses one interesting question. It specifies that the handler consumes two inputs with non-trivial data definitions. On one hand, the ShotWorld is self-referential data definition. On the other hand, the definition for KeyEvents is a large enumeration. For now, we have you “guess” which of the two arguments should drive the development of the template; later we will study such cases in depth.

(define (keyh w ke) (cond [(key=? ke "left") ...] [(key=? ke "right") ...] ... [(key=? ke " ") ...] ... [(key=? ke "a") ...] ... [(key=? ke "z") ...]))

Exercise 150. Equip the program in figure 42 with tests and make sure it passes those. Explain what main does. Then run the program via main.

Exercise 151. Experiment whether the arbitrary decisions concerning constants are truly easy to change. For example, determine whether changing a single constant definition achieves the desired outcome:

change the height of the canvas to 220 pixels;

change the width of the canvas to 30 pixels;

change the x location of the line of shots to “somewhere to the left of the middle;”

change the background to a green rectangle; and

change the rendering of shots to a red elongated rectangle.

Also check whether it is possible to double the size of the shot without changing anything else, change its color to black, or change its form to "outline".

Exercise 152. If you run main, press the space bar (fire a shot), and wait for a good amount of time, the shot disappears from the canvas. When you shut down the world canvas, however, the result is a world that still contains this invisible shot.

Design an alternative tock function, which not just moves shots one pixel per clock tick but also eliminates those whose coordinates places them above the canvas. Hint You may wish to consider the design of an auxiliary function for the recursive cond clause.

Exercise 153. Turn the exercise of exercise 147 into a world program. Its main function should consume the rate at which to display the balloon throwing:

; Number -> ShotWorld ; displays the student riot at rate ticks per second (define (main rate) (big-bang '() (on-tick drop-balloon rate) (stop-when long-enough) (to-draw to-image))) Naturally, the riot should stop when the students are out of balloons.

### 11` `More on Lists

#### 11.1` `Functions that Produce Lists

Call this new function wage*. Its task is to process all employee work hours and to determine the wages due to each of them. For simplicity, let us assume that the input is a list of numbers, each representing the number of hours that one employee worked, and that the expected result is a list of the weekly wages earned, also represented with a list of numbers.

; List-of-numbers -> List-of-numbers ; computes the weekly wages for all given weekly hours (define (wage* alon) '())

(define (wage* alon) (cond [(empty? alon) ...] [else (... (first alon) ... (wage* (rest alon)) ...)]))

It is now time for the most creative design step. Following the design recipe, we consider each cond-line of the template in isolation. For the non-recursive case, (empty? alon) is true, meaning the input is '(). The examples from above specify the desired answer, '(), and so we are done.

(first alon) yields the first number on alon, which is the first number of hours worked;

(rest alon) is the rest of the given list; and

(wage* (rest alon)) says that the rest is processed by the very function we are defining. As always we use its signature and its purpose statement to figure out the result of this expression. The signature tells us that it is a list of numbers, and the purpose statement explains that this list represents the list of wages for its input, which is the rest of the list of hours.

; List-of-numbers -> List-of-numbers ; computes the weekly wages for all given weekly hours (define (wage* alon) (cond [(empty? alon) '()] [else (cons (wage (first alon)) (wage* (rest alon)))])) ; Number -> Number ; computes the wage for h hours of work (define (wage h) (* 12 h))

Exercise 154. Translate the examples into tests and make sure they all succeed. Then change the function in figure 43 so that everyone gets $14 per hour. Now revise the entire program so that changing the wage for everyone is a single change to the entire program and not several.

Exercise 155. No employee could possibly work more than 100 hours per week. To protect the company against fraud, the function should check that no item of the input list of wage* exceeds 100. If one of them does, the function should immediately signal an error. How do we have to change the function in figure 43 if we want to perform this basic reality check?

Show the products of the various steps in the design recipe. If you are stuck, show someone how far you got according to the design recipe. The recipe isn’t just a design tool for you to use; it is also a diagnosis system so that others can help you help yourself.

Exercise 156. Design convertFC. The function converts a list of Fahrenheit measurements to a list of Celsius measurements.

Exercise 157. Design the function convert-euro, which converts a list of US$ amounts into a list of € amounts. Look up the current exchange rate on the web.

Generalize convert-euro to the function convert-euro*, which consumes an exchange rate and a list of US$ amounts and converts the latter into a list of € amounts.

Exercise 158. Design the function subst-robot, which consumes a list of toy descriptions (strings) and replaces all occurrences of "robot" with "r2d2"; all other descriptions remain the same.

Generalize subst-robot to the function substitute. The new function consumes two strings, called new and old, and a list of strings. It produces a new list of strings by substituting all occurrences of old with new.

#### 11.2` `Structures in Lists

Representing a work week as a number is a bad choice because the printing of a paycheck requires more information than hours worked per week. Also, not all employees earn the same amount per hour. Fortunately a list may contain items other than atomic values; indeed, lists may contain whatever values we want, especially structures.

(define-struct work [employee rate hours]) ; Work is a structure: (make-work String Number Number). ; interpretation (make-work n r h) combines the name (n) ; with the pay rate (r) and the number of hours (h) worked.

; Low (list of works) is one of: ; – '() ; – (cons Work Low) ; interpretation an instance of Low represents the work efforts ; of some hourly employees

'() (cons (make-work "Robby" 11.95 39) '()) (cons (make-work "Matthew" 12.95 45) (cons (make-work "Robby" 11.95 39) '()))

; Low -> List-of-numbers ; computes the weekly wages for all given weekly work records (define (wage*.v2 an-low) '())

The third step of the design recipe is to work through an example. Let us start with the second list above. It contains one work record, namely, (make-work "Robby" 11.95 39). Its interpretation is that "Robby" worked for 39 hours and that he is paid at the rate of $11.95 per hour. Hence his wage for the week is $466.05, i.e., (* 11.95 39). The desired result for wage*.v2 is therefore (cons 466.05 '()). Naturally, if the input list contained two work records, we would perform this kind of computation twice, and the result would be a list of two numbers. Before you read on, determine the expected result for the third data example above.

(check-expect (wage*.v2 (cons (make-work "Robby" 11.95 39) '())) (cons (* 11.95 39) '()))

(define (wage*.v2 an-low) (cond [(empty? an-low) ...] [(cons? an-low) (... (first an-low) ... (wage*.v2 (rest an-low)) ...)]))

(define (wage*.v2 an-low) (cond [(empty? an-low) ...] [(cons? an-low) (... (first an-low) ... (work-employee (first an-low)) ... (work-rate (first an-low)) ... (work-hours (first an-low)) (wage*.v2 (rest an-low)) ...)]))

(define (wage*.v2 an-low) (cond [(empty? an-low) ...] [(cons? an-low) (... (for-work (first an-low)) ... (wage*.v2 (rest an-low)) ...)])) ; Work -> ??? ; a template for functions that process work structures (define (for-work w) (... (work-employee w) ... (work-rate w) ... (work-hours w) ...))

(first an-low) extracts the first work structure from the list;

(for-work ...) says that you wish to design a function that processes work structures;

(rest an-low) extracts the rest of the given list; and

according to the purpose statement, (wage*.v2 (rest an-low)) determines the list of wages for all the work records other than the first one.

; Low -> List-of-numbers ; computes the weekly wages for all given weekly work records (check-expect (wage*.v2 (cons (make-work "Robby" 11.95 39) '())) (cons (* 11.95 39) '())) (define (wage*.v2 an-low) (cond [(empty? an-low) '()] [(cons? an-low) (cons (wage.v2 (first an-low)) (wage*.v2 (rest an-low)))])) ; Work -> Number ; computes the wage for the given work record w (define (wage.v2 w) (* (work-rate w) (work-hours w)))

Exercise 159. The wage*.v2 function consumes a list of work records and produces a list of numbers. Of course, functions may also produce lists of structures.

Develop a data representation for pay checks. Assume that a pay check contains two pieces of information: the name of the employee and an amount. Then design the function wage*.v3. It consumes a list of work records and computes a list of (representations of) pay checks from it, one per work record.

In reality, a pay check also contains an employee number. Develop a data representation for employee information and change the data definition for work records so that it uses employee information and not just a string for the employee’s name. Also change your data representation of pay checks so that it contains an employee’s name and number, too. Finally, design wage*.v4, a function that maps lists of revised work records to lists of revised pay checks.

Note This exercise demonstrates the iterative refinement of a task. Instead of using data representations that include all relevant information, we started from simplistic representation of pay checks and gradually made the representation realistic. For this simple program, refinement is overkill; later we will encounter situations where iterative refinement is not just an option but a necessity.

Exercise 160. Design the function sum, which consumes a list of Posns and produces the sum of all of its x coordinates.

Exercise 161. Design the function translate. It consumes and produces lists of Posns. For each (make-posn x y) in the former, the latter contains (make-posn x (+ y 1)).—

We borrow the word “translate” from geometry, where the movement of a point by a constant distance along a straight line is called a translation.

Exercise 162. Design the function legal. Like translate from exercise 161 the function consumes and produces a list of Posns. The result contains all those Posns whose x coordinates are between 0 and 100 and whose y coordinates are between 0 and 200.

(define-struct phone [area switch four]) ; A Phone is a structure: ; (make-phone Three Three Four) ; A Three is between 100 and 999. ; A Four is between 1000 and 9999. Design the function replace. It consumes a list of Phones and produces one. It replaces all occurrence of area code 713 with 281.

#### 11.3` `Lists in Lists, Files

Functions And Programs introduces read-file, a function for readingUse (require 2htdp/batch-io). an entire text file as a string. In other words, the creator of read-file chose to represent text files as strings, and the function creates the data representation for specific files (specified by a name). Text files aren’t plain long texts or strings, however. They are organized into lines and words, rows and cells, and many other ways. In short, representing the content of a file as a plain string might work on rare occasions but is usually a bad choice.

ttt.txt

TTT

Put up in a place

where it's easy to see

the cryptic admonishment

T.T.T.

When you feel how depressingly

slowly you climb,

it's well to remember that

Things Take Time.

Piet Hein

(read-file "ttt.txt")

"TTT\n \nPut up in a place\nwhere ..."

- One way to represent this file is as a list of lines, where each line is represented as one string:Here the second item of the list is the empty string because the file contains an empty line.
- Another way is to use a list of all possible words, again each word represented to a string:Note how the empty second line disappears with this representation. After all, there are no words on the empty line.
- And a third representation mixes the first two with a list of list of words:
(cons (cons "TTT" '()) (cons '() (cons (cons "Put" (cons "up" (cons "in" (cons ... '())))) (cons ... '())))) The advantage of this representation over the second one is that it preserves the organization of the file, including the emptiness of the second line. Of course, the price is that all of a sudden lists contain lists.

Before we get started, take a look at figure 45. It introduces a
number of useful file reading functions that come with BSL. They are not
comprehensive and there are many other ways of dealing with text from
files, and you will need to know a lot more to deal with all possible text
files. For our purposes here—

; String -> String ; produces the content of file f as a string (define (read-file f) ...) ; String -> List-of-string ; produces the content of file f as a list of strings, ; one per line (define (read-lines f) ...) ; String -> List-of-string ; produces the content of file f as a list of strings, ; one per word (define (read-words f) ...) ; String -> List-of-list-of-string ; produces the content of file f as a list of list of ; strings, one list per line and one string per word (define (read-words/line f) ...) ; All functions that read a file consume the name of a file ; as a String argument. They assume the specified file ; exists in the same folder as the program; if not they ; signal an error.

One problem with figure 45 is that they use the names of two data definitions that do not exist yet, including one involving list-containing lists. As always, we start with a data definition, but this time, we leave this task to you. Hence, before you read on, solve the following exercises. The solutions are needed to make complete sense out of the figure, and without working through the solutions, you cannot really understand the rest of this section.

Exercise 164. You know what the data definition for List-of-strings looks like. Spell it out. Make sure that you can represent Piet Hein’s poem as an instance of the definition where each line is a represented as a string and another one where each word is a string. Use read-lines and read-words to confirm your representation choices.

Next develop the data definition for List-of-list-of-strings. Again, represent Piet Hein’s poem as an instance of the definition where each line is a represented as a list of strings, one per word, and the entire poem is a list of such line representations. You may use read-words/line to confirm your choice.

As you probably know, operating systems come with programs that measure various statistics of files. Some count the number of lines, others count the number of words in a file. A third may determine how many words appear per line. Let us start with the latter to illustrate how the design recipe helps with the design of complex functions.

; LLS -> List-of-numbers ; determines the number of words on each line (define (words-on-line lls) '())

(define line0 (cons "hello" (cons "world" '()))) (define line1 '()) (define lls0 '()) (define lls1 (cons line0 (cons line1 '())))

Once you have data examples, it is easy to formulate functional examples; just imagine applying the function to each of the data example. When apply words-on-line to lls0, you should get the empty list back, because there are no lines. When you apply words-on-line to lls1, you should get a list of two numbers back, because there are two lines. The two numbers are 2 and 0, respectively, given that the two lines in lls1 contain two and no words each.

(check-expect (words-on-line lls0) '()) (check-expect (words-on-line lls1) (cons 2 (cons 0 '())))

(define (words-on-line lls) (cond [(empty? lls) ...] [else (... (first lls) ; a list of strings ... (words-on-line (rest lls)) ...)]))

(define (line-processor ln) (cond [(empty? lls) ...] [else (... (first ln) ; a string ... (line-processor (rest ln)) ...)]))

(first lls) extracts the first line from the non-empty list of (represented) lines;

(line-processor (first lls)) suggests that we may wish to design an auxiliary function to process this line;

(rest lls) is the rest of the list of line;

(words-on-line (rest lls)) computes a list of words per line for the rest of the list. How do we know this? We promised just that with the signature and the purpose statement for words-on-line.

; List-of-strings -> Number ; counts the number of words on los (define (words# los) 0)

(define (words# los) (how-many los))

; A LLS is one of: ; – '() ; – (cons Los LLS) ; interpretation a list of lines, each line is a list of strings (define line0 (cons "hello" (cons "world" '()))) (define line1 '()) (define lls0 '()) (define lls1 (cons line0 (cons line1 '()))) ; LLS -> List-of-numbers ; determines the number of words on each line (check-expect (words-on-line lls0) '()) (check-expect (words-on-line lls1) (cons 2 (cons 0 '()))) (define (words-on-line lls) (cond [(empty? lls) '()] [else (cons (length (first lls)) (words-on-line (rest lls)))]))

You may wish to look over the rest of functions that come with BSL. Some may look obscure now, but they may just be useful in one of the upcoming problems. Then again, using such functions saves only your time. You just may wish to design them from scratch to practice your design skills or to fill time.

Figure 46 summarizes the full design for our sample problem. The figure includes two test cases. Also, instead of using the separate function words#, the definition of words-on-line simply calls the length function that comes with BSL. Experiment with the definition in DrRacket and make sure that the two test cases cover the entire function definition.

; String -> List-of-numbers ; counts the number of words on each line in the given file (define (file-statistic file-name) (words-on-line (read-words/line file-name)))

This idea of composing a built-in function with a newly designed function is common. Naturally, people don’t design functions randomly and expect to find something in the chosen programming language to complement their design. Instead, program designers plan ahead and design the function to the output that available functions deliver. More generally still and as mentioned above, it is common to think about a solution as a composition of two computations and to develop an appropriate data collection with which to communicate the result of one computation to the second one, where each computation is each implemented with a function.

Exercise 165. Design a program that converts a list of lines into a string. The strings should be separated by blank spaces (" "). The lines should be separated with a newline ("\n").

Challenge: Remove all extraneous white spaces in your version of the Piet Hein poem. When you are finished with the design of the program, use it like this:(write-file "ttt.dat" (collapse (read-words/line "ttt.txt")))

The two files "ttt.dat" and "ttt.txt" should be identical.

Exercise 166. Design a program that removes all articles from a text file. The program consumes the name n of a file, reads the file, removes the articles, and writes the result out to a file whose name is the result of concatenating "no-articles-" with n. For this exercise, an article is one of the following three words: "a", "an", and "the".

Use read-words/line so that the transformation retains the organization of the original text into lines and words. When the program is designed, run it on the Piet Hein poem.

Exercise 167. Design a program that encodes text files numerically. Each letter in a word should be encoded as a numeric three-letter string with a value between 0 and 256. Here is our encoding function for letters:

; 1String -> String ; converts the given 1string into a three-letter numeric string ; 1String -> String ; auxiliary for stating tests (define (code1 c) (number->string (string->int c))) (check-expect (encode-letter "\t") (string-append "00" (code1 "\t"))) (check-expect (encode-letter "a") (string-append "0" (code1 "a"))) (check-expect (encode-letter "z") (code1 "z")) (define (encode-letter s) (cond [(< (string->int s) 10) (string-append "00" (code1 s))] [(< (string->int s) 100) (string-append "0" (code1 s))] [else (code1 s)])) Before you start, explain this function. Also recall how a string can be converted into a list of 1Strings.Again, use read-words/line to preserve the organization of the file into lines and words.

Exercise 168. Design a BSL program that simulates the Unix command wc. The purpose of the command is to count the number of 1Strings, words, and lines in a given file. That is, the command consumes the name of a file and produces a value that consists of three numbers.

Exercise 169. Mathematics teachers may have introduced you to matrix calculations by now. Numeric programs deal with those, too. In principle, matrix just means rectangle of numbers. Here is one possible data representation for matrices:

; A Matrix is one of: ; – (cons Row '()) ; – (cons Row Matrix) ; constraint all rows in matrix are of the same length ; An Row is one of: ; – '() ; – (cons Number Row) Note the constraints on matrices. Study the data definition and translate the two-by-two matrix consisting of the numbers 11, 12, 21, 22 into this data representation. Stop, don’t read on until you have figured out the data examples.Here is the solution for the five-second puzzle:

(define row1 (cons 11 (cons 12 '()))) (define row2 (cons 21 (cons 22 '()))) (define mat1 (cons row1 (cons row2 '()))) If you didn’t create it yourself, study it now.The following function implements the important mathematical operation of transposing the entries in a matrix. To transpose means to mirror the entries along the diagonal, that is, the line from the top-left to the bottom-right. Again, stop! Transpose mat1 by hand, then read on:

; Matrix -> Matrix ; transpose the items on the given matrix along the diagonal (define wor1 (cons 11 (cons 21 '()))) (define wor2 (cons 12 (cons 22 '()))) (define tam1 (cons wor1 (cons wor2 '()))) (check-expect (transpose mat1) tam1) (define (transpose lln) (cond [(empty? (first lln)) '()] [else (cons (first* lln) (transpose (rest* lln)))])) The definition assumes two auxiliary functions:

first*, which consumes a matrix and produces the first column as a list of numbers;

rest*, which consumes a matrix and removes the first column. The result is a matrix.

Even though you lack definitions for these functions, you should be able to understand how transpose works. You should also understand that you cannot design this function with the design recipes you have seen so far. Explain why.

Design the two “wish list” functions. Then complete the design of the transpose with some test cases.

#### 11.4` `A Graphical Editor, Revisited

A Graphical Editor is about the design of an interactive graphical one-line editor. It suggests two different ways to represent the state of the editor and urges you to explore both: a structure that contains pair of strings or a structure that combines a string with an index to a current position (see exercise 80).

(define-struct editor [pre post]) ; An Editor is (make-editor Lo1S Lo1S) ; An Lo1S is one of: ; – empty ; – (cons 1String Lo1S)

(define good (cons "g" (cons "o" (cons "o" (cons "d" '()))))) (define all (cons "a" (cons "l" (cons "l" '())))) (define lla (cons "l" (cons "l" (cons "a" '())))) ; data example 1: (make-editor all good) ; data example 2: (make-editor lla good)

- (make-editor pre post) could mean the letters in pre precede the cursor and those in post succeed it and that the combined text is
(string-append (implode pre) (implode post))

- (make-editor pre post) could equally well mean that the letters in pre precede the cursor in reverse order. If so, we obtain the text in the displayed editor like this:
(string-append (implode (rev pre)) (implode post))

The function rev must consume a list of 1Strings and produce their reverse.

Both interpretations are fine choices, but it turns out that using the second one greatly simplifies the design of the program. The rest of this section demonstrates this point, illustrating the use of lists inside of structures at the same time. To appreciate the lesson properly, you should have solved the exercises in A Graphical Editor.

; Lo1s -> Lo1s ; produces a reverse version of the given list (check-expect (rev (cons "a" (cons "b" (cons "c" '())))) (cons "c" (cons "b" (cons "a" '())))) (define (rev l) l)

; Lo1s 1String -> Lo1s ; creates a new list by adding s to the end of l (check-expect (add-at-end (cons "c" (cons "b" '())) "a") (cons "c" (cons "b" (cons "a" '())))) (define (add-at-end l s) l)

(define (add-at-end l s) (cond [(empty? l) ...] [else (... (first l) ... ... (add-at-end (rest l) s) ...)]))

(add-at-end '() s)

(define (add-at-end l s) (cond [(empty? l) (cons s '())] [else (cons (first l) (add-at-end (rest l) s))]))

Exercise 170. Design the function create-editor. The function consumes two strings and produces an Editor. The first string is the text to the left of the cursor and the second string is the text to the right of the cursor. The rest of the section relies on this function.

; constants (define HEIGHT 20) ; the height of the editor (define WIDTH 200) ; its width (define FONT-SIZE 16) ; the font size (define FONT-COLOR "black") ; the font color ; graphical constants (define MT (empty-scene WIDTH HEIGHT)) (define CURSOR (rectangle 1 HEIGHT "solid" "red"))

; Editor -> Image ; renders an editor as an image of the two texts separated by the cursor (define (editor-render e) MT) ; Editor KeyEvent -> Editor ; deals with a key event, given some editor (define (editor-kh ed ke) ed)

; main : String -> Editor ; launches the editor given some initial string (define (main s) (big-bang (create-editor s "") (on-key editor-kh) (to-draw editor-render)))

(check-expect (editor-kh (create-editor "" "") "e") (create-editor "e" "")) (check-expect (editor-kh (create-editor "cd" "fgh") "e") (create-editor "cde" "fgh"))

Before you read on, you should make up examples that illustrate how editor-kh works when you press the backspace ("\b") key to delete some letter, the "left" and "right" arrow keys to move the cursor, or some other arrow keys. In all cases, consider what should happen when the editor is empty, when the cursor is at the left end or right end of the non-empty string in the editor, and when it is in the middle. Even though you are not working with intervals here, it is still a good idea to develop examples for the “extreme” cases.

Once you have test cases, it is time to develop the template. In the case of editor-kh you are working with a function that consumes two complex forms of data: one is a structure containing lists, the other one is a large enumeration of strings. Generally speaking, the use of two complex inputs calls for a special look at the design recipe; but in cases like these, it is also clear that you should deal with one of the inputs first, namely, the keystroke.

(define (editor-kh ed k) (cond [(key=? k "left") ...] [(key=? k "right") ...] [(key=? k "\b") ...] [(key=? k "\t") ...] [(key=? k "\r") ...] [(= (string-length k) 1) ...] [else ...]))

Exercise 171. Explain why the template for editor-kh deals with "\t" and "\r" before it checks for strings of length 1.

(define (editor-kh ed k) (cond [(key=? k "left") (editor-lft ed)] [(key=? k "right") (editor-rgt ed)] [(key=? k "\b") (editor-del ed)] [(key=? k "\t") ed] [(key=? k "\r") ed] [(= (string-length k) 1) (editor-ins ed k)] [else ed]))

(check-expect (editor-ins (make-editor '() '()) "e") (make-editor (cons "e" '()) '())) (check-expect (editor-ins (make-editor (cons "d" '()) (cons "f" (cons "g" '()))) "e") (make-editor (cons "e" (cons "d" '())) (cons "f" (cons "g" '()))))

At this point, you should do two things. First, run the tests for this function. Second, use the interpretation of Editor and explain abstractly why this function performs the insertion. And if this isn’t enough, you may wish to compare this simple definition with the one from exercise 77 and figure out why the other one needs an auxiliary function while our definition here doesn’t.

; Editor -> Editor ; moves the cursor position one 1String left, if possible (define (editor-lft ed) ed) ; Editor -> Editor ; moves the cursor position one 1String right, if possible (define (editor-rgt ed) ed) ; Editor -> Editor ; deletes one 1String to the left of the cursor, if possible (define (editor-del ed) ed) Again, it is critical that you work through a good range of examples.

(place-image/align (beside (text "pre" FONT-SIZE FONT-COLOR) CURSOR (text "post" FONT-SIZE FONT-COLOR)) 1 1 "left" "top" MT)

; Editor -> Image (define (editor-render e) (place-image/align (beside (editor-text (editor-pre e)) CURSOR (editor-text (editor-post e))) 1 1 "left" "top" MT))

; Lo1s -> Image ; renders a list of 1Strings as a text image (define (editor-text s) (text "" FONT-SIZE FONT-COLOR))

(create-editor "pre" "post")

(check-expect (editor-text (cons "p" (cons "o" (cons "s" (cons "t" '()))))) (text "post" FONT-SIZE FONT-COLOR))

(define (editor-text s) (cond [(empty? s) ...] [else (... (first s) ... (editor-text (rest s)) ...)]))

Exercise 173. Design editor-text. That is, use the standard design recipe and do not fall back on implode.

(define (editor-render ed) (place-image/align (beside (editor-text (reverse (editor-pre ed))) CURSOR (editor-text (editor-post ed))) 1 1 "left" "top" MT))

Note Modern applications allow users to position the cursor with the mouse (or other gesture-based devices). While it is in principle possible to add this capability to your editor, we wait with doing so until A Graphical Editor, with Mouse.

### 12` `Design by Composition

This last chapter of part II covers “design by composition.” By now you know that programs are complex products and that their production requires the design of many collaborating functions. This collaboration works well if the designer knows when to design several functions and how to compose these functions into one program.

You have encountered this need to design interrelated functions several times. Sometimes a problem statement implies several different tasks, and each task is best realized with a function. At other times, a data definition may refer to another one, and in that case, a function processing the former kind of data relies on a function processing the latter.

In this chapter, we present yet other scenarios that call for the design of many functions and their composition. To support this kind of work, the chapter presents some informal guidelines on divvying up functions and composing them. The next chapter then introduces some well-known examples whose solutions rely on the use of these guidelines and the design recipe in general. Since these examples demand complex forms of lists, however, this chapter starts with a section on a convenient way to write down complex lists.

#### 12.1` `The list Function

At this point, you should have tired of writing so many conses just to create a list, especially for lists that contain a bunch of values. Fortunately, we have an additional teaching language for you that provides mechanisms for simplifying this part of a programmer’s life. BSL+Yes, you have graduated from BSL. It is time to use the “Language” menu and to select the “Choose Language” entry. From now until further notice, use “Beginning Student Language with List Abbreviations” to work through the book. does so, too.

(list 0 1 2 3 4 5 6 7 8 9)

(list (list "bob" 0 "a") (list "carl" 1 "a") (list "dana" 2 "b") (list "erik" 3 "c") (list "frank" 4 "a") (list "grant" 5 "b") (list "hank" 6 "c") (list "ian" 8 "a") (list "john" 7 "d") (list "karel" 9 "e"))

Start by determining how many items each list and each nested list contains. Use check-expect to express your answers; this ensures that your abbreviations are really the same as the long-hand.

Use check-expect to express your answers.

Exercise 176. On some occasions lists are formed with cons and list. Reformulate the following lists using cons and '() exclusively:Then formulate the lists using only list. Use check-expect to express your answers.

Use check-expect to express your answers.

#### 12.2` `Composing Functions

Formulate auxiliary function definitions for every dependency between quantities in the problem statement. In short, design one function per task.

Formulate auxiliary function definitions when one data definition points to a second data definition. Roughly, design one template per data definition.

If the composition of values requires knowledge of a particular domain of application—

for example, composing two (computer) images, accounting, music, or science— design an auxiliary function. If the composition of values requires a case analysis of the available values—

for example, is a number positive, zero, or negative— use a cond expression. If the cond looks complex, design an auxiliary function whose inputs are the partial results and whose function body is the cond expression. Doing so separates out the case analysis from the recursive process. If the composition of values must process an element from a self-referential data definition—

a list, a natural number, or something like those— design an auxiliary function. If everything fails, you may need to design a more general function and define the main function as a specific use of the general function. This suggestion sounds counter-intuitive but it is called for in a remarkably large number of cases.

The last two criteria are situations that we haven’t discussed in any detail, though examples have come up before. The next two sections illustrate these principles with additional examples.

Wish Lists

Maintain a list of function headers that must be designed to complete a program. Writing down complete function headers ensures that you can test those portions of the programs that you have finished, which is useful even though many tests will fail. Of course, when the wish list is empty, all tests should pass and all functions should be covered by tests.

#### 12.3` `Recursive Auxiliary Functions

People need to sort things all the time, and so do programs. Investment advisors sort portfolios by the profit each holding generates. Game programs sort lists of players according to scores. And mail programs sort messages according to date or sender or some other criteria.

Sample Problem: Design a function that sorts a list of (real) numbers.

; List-of-numbers -> List-of-numbers ; produces a sorted version of alon (define (sort> alon) alon)

; List-of-numbers -> List-of-numbers ; rearrange alon in descending order (check-expect (sort> '()) '()) (check-expect (sort> (list 12 20 -5)) (list 20 12 -5)) (check-expect (sort> (list 3 2 1)) (list 3 2 1)) (check-expect (sort> (list 1 2 3)) (list 3 2 1)) (define (sort> alon) alon)

(define (sort> alon) (cond [(empty? alon) ...] [else (... (first alon) ... (sort> (rest alon)) ...)]))

Inserting a number into a sorted list clearly isn’t a simple task. It demands searching through the sorted list to find the proper place of the item. Searching through any list, however, demands an auxiliary function, because lists are of arbitrary size and, by hint 3 of the preceding section, processing values of arbitrary calls for the design of an auxiliary function.

; Number List-of-numbers -> List-of-numbers ; inserts n into the sorted list of numbers alon (define (insert n alon) alon)

(check-expect (insert 5 '()) (list 5))

(check-expect (insert 5 (list 6)) (list 6 5)) (check-expect (insert 5 (list 4)) (list 5 4))

(check-expect (insert 12 (list 20 -5)) (list 20 12 -5))

Note what the development of examples teaches us. The insert function has to find the first number that is smaller than the given n. When there is no such number, the function eventually reaches the end of the list and it must add n to the end. Now, before we move on to the template, you should work out some additional examples. To do so, you may wish to use the supplementary examples for sort>.

(define (insert n alon) (cond [(empty? alon) ...] [else (... (first alon) ... (insert n (rest alon)) ...)]))

To fill the gaps in the template of insert, we again proceed on a case-by-case basis. The first case concerns the empty list. According to the first example, (list n) is the expression needed in the first cond clause, because it constructs a sorted list from n and alon.

(insert 7 (list 6 5 4))

(insert 0 (list 6 2 1 -1))

If so, all the items in alon are smaller than n because alon is already sorted. The answer in that case is (cons n alon).

- If, however, n is smaller than (first alon), then the function has not yet found the proper place to insert n into alon. The first item of the result must be (first alon) and that n must be inserted into (rest alon). The final result in this case isbecause this list contains n and all items of alon in sorted order—
which is what we need.

Figure 47 contains the complete definitions of insert and sort>. Copy it into the definition area of DrRacket, add the test cases back in, and test the program. All tests should pass now and they should cover all expressions.

Terminology This particular program for sorting is known as insertion sort in the programming literature. Later we will study alternative ways to sort lists, using an entirely different design strategy.

; List-of-numbers -> List-of-numbers ; produces a sorted version of alon (define (sort> alon) (cond [(empty? alon) '()] [(cons? alon) (insert (first alon) (sort> (rest alon)))])) ; Number List-of-numbers -> List-of-numbers ; inserts n into the sorted list of numbers alon (define (insert n alon) (cond [(empty? alon) (cons n '())] [else (if (>= n (first alon)) (cons n alon) (cons (first alon) (insert n (rest alon))))]))

Exercise 179. Recall from Intermezzo: BSL that BSL comes with several different ways to formulate tests. One of them is check-satisfied, which determines whether an expression satisfies a certain property.

Use sorted>? from exercise 139 to re-formulate the tests for sort> with check-satisfied.

Now consider this function definition:

; List-of-numbers -> List-of-numbers ; produces a sorted version of l (define (sort>/bad l) '(9 8 7 6 5 4 3 2 1 0)) Can you formulate a test case that shows sort>/bad is not a sorting function? Can you use check-satisfied to formulate this test case?Notes (1) What may surprise you here is that we define a function to create a test. In the real world, this step is common and, on occasion, you really need to design functions for tests—

with their own tests and all. (2) Formulating tests with check-satisfied is occasionally easier than using check-expect (or other forms), and it is also a bit more general. When the predicate completely describes the relationship between all possible inputs and outputs of a function, computer scientists speak of a specification. Specifying with lambda explains how to specific sort> completely.

(define-struct email [from date message]) ; A Email Message is a structure: ; (make-email String Number String) ; interpretation (make-email f d m) represents text m sent by ; f, d seconds after the beginning of time Also develop a program that sorts lists of email messages by name. To compare two strings alphabetically, use the string<? primitive.

(define-struct gp [name score]) ; A GamePlayer is a structure: ; (make-gp String Number) ; interpretation (make-gp p s) represents player p who scored ; a maximum of s points

; Number List-of-numbers -> Boolean (define (search n alon) (cond [(empty? alon) #false] [else (or (= (first alon) n) (search n (rest alon)))])) It determines whether some number occurs in a list of numbers. The function may have to traverse the entire list to find out that the number of interest isn’t contained in the list.Develop the function search-sorted, which determines whether a number occurs in a sorted list of numbers. The function must take advantage of the fact that the list is sorted.

Exercise 183. Design prefixes. The function consumes a list of 1Strings and produces the list of all prefixes. Recall that a list p is a prefix of l if p and l are the same up through all items in p. For example, (list 1 2 3) is a prefix of itself and (list 1 2 3 4).

Design the function suffixes, which consumes a list of 1Strings and produces all suffixes. A list s is a suffix of l if p and l are the same from the end, up through all items in s. For example, (list 2 3 4) is a suffix of itself and (list 1 2 3 4).

#### 12.4` `Generalizing Functions

Auxiliary functions are also needed when a problem statement is too narrow. Conversely, it is common for programmers to generalize a given problem just a bit to simplify the solution process. When they discover the need for a generalized solution, they design an auxiliary function that solves the generalized problem and a main function that just calls this auxiliary function with special arguments.

Sample Problem: Design a program that renders a polygon into an empty 50 by 50 scene.

A polygon is a planar figure with at least three corners consecutively connected by three straight sides. And so on.

As the domain knowledge statement says, a polygon consists of at least three sides and that means at least three Posns. Thus the answer to our question is that representations of polygons should be lists of at least three Posns.

The point of this discussion is that a naively chosen data representation—

(define MT (empty-scene 50 50)) ; Polygon -> Image ; renders the given polygon p into MT (define (render-poly p) MT)

(check-expect (render-poly (list (make-posn 20 0) (make-posn 10 10) (make-posn 30 10))) (scene+line (scene+line (scene+line MT 20 0 10 10 "red") 10 10 30 10 "red") 30 10 20 0 "red"))

(check-expect (render-poly (list (make-posn 10 10) (make-posn 20 10) (make-posn 20 20) (make-posn 10 20))) (scene+line (scene+line (scene+line (scene+line MT 10 10 20 10 "red") 20 10 20 20 "red") 20 20 10 20 "red") 10 20 10 10 "red"))

In general, it is better to formulate conditions via built-in predicates and selectors than your own (recursive) functions. We will explain this remark in Intermezzo: The Cost of Computation.

(define (render-poly p) (cond [(empty? (rest (rest (rest p)))) (... (first p) ... (second p) ... (third p) ...)] [else ( ... (first p) ... (render-poly (rest p)) ...)]))

; Image Posn Posn -> Image ; draws a red line from Posn p to Posn q into im (define (render-line im p q) im)

(render-line (render-line (render-line MT (first p) (second p)) (second p) (third p)) (third p) (first p))

(define (render-poly p) (cond [(empty? (rest (rest (rest p)))) (render-line (render-line (render-line MT (first p) (second p)) (second p) (third p)) (third p) (first p))] [else (render-line (render-poly (rest p)) (first p) (second p))]))

; Image Posn Posn -> Image ; renders a line from p to q into im (define (render-line im p q) (scene+line im (posn-x p) (posn-y p) (posn-x q) (posn-y q) "red"))

Sixth and last, we must test the functions. You should add a test for render-line but for now you may just accept our correctness promise. In that case, testing immediately reveals flaws with the definition of render-poly; in particular, the test case for the square fails. On one hand, this is fortunate because it is the purpose of tests to find problems before they affect regular consumers. On the other hand, the flaw is unfortunate because we followed the design recipe, we made fairly regular decisions, and yet the function doesn’t work.

Before you give up hope in such a situation, you should experiment with the function in DrRacket’s interactions area. For our example, the results are illuminating. Here is the failing test case, with the input on the left and the output on the right:

p =

(render-polygon p) =

(list (make-posn 10 10) (make-posn 20 10) (make-posn 20 20) (make-posn 10 20))

p =

(render-polygon p) =

(list (make-posn 10 5) (make-posn 10 10) (make-posn 20 10) (make-posn 20 20) (make-posn 10 20))

As a matter of fact, one could also argue that render-polygon is really the function that connects the successive dots specified by a list of Posns and connects the first and the last Posn of the trailing triangle. If we don’t draw this last, extra line, render-polygon is just a “connects the dots” function. And as such, it almost solves our original problem; all that is left to do is to add a line from the first Posn to the last one in the given Polygon.

Put differently, the analysis of our failure suggests two ideas at once. First, we should solve a different, a more general looking problem. Second, we should use the solution for this generalized problem to solve the original one.

Sample Problem: Design a program that connects a bunch of dots.

(check-expect (connect-dots (list (make-posn 20 0) (make-posn 10 10) (make-posn 30 10))) (scene+line (scene+line MT 20 0 10 10 "red") 10 10 30 10 "red"))

Exercise 184. Adapt the second example for render-poly to connect-dots.

(define (connect-dots p) (cond [(empty? (rest p)) (... (first p) ...)] [else (... (first p) ... (connect-dots (rest p)) ...)]))

(define (connect-dots p) (cond [(empty? (rest p)) MT] [else (render-line (connect-dots (rest p)) (first p) (second p))]))

about the equivalence of

Our arguments in this book are informal. If you ever wish to know that Polygon is really the same set as NELoP or that connect-dots generalizes render-poly, you will need to construct a formal argument, called a proof. While this book’s design process is deeply informed by logic, a course on logic in computation is the ideal complement if you ever get interested in profs. In general, logic is to computing what analysis is to engineering.

Conversely, we say that connect-dots generalizes render-poly. Every input for the latter is also an input for the former. Or in terms of data definitions, every Polygon is also a NELoP. But, there are many NELoPs that are not Polygons. To be precise, all lists of Posns that contain two items or one belong to NELoP but not to Polygon. The key insight for you is, however, that just because a function has to deal with more inputs than another function does not mean that the former is more complex than the latter; generalizations often simplify function definitions.

; Polygon -> Image ; adds an image of p to MT (define (render-polygon p) (render-line (connect-dots p) (first p) (last p)))

Exercise 185. Argue why it is acceptable to use last on Polygons. Also argue why you may reuse the template for connect-dots for last:

(define (last p) (cond [(empty? (rest p)) (... (first p) ...)] [else (... (first p) ... (last (rest p)) ...)])) Finally, develop examples for last, turn them into tests, and ensure that the definition of last in figure 48 works on your examples.

; A Polygon is one of: ; – (list Posn Posn Posn) ; – (cons Posn Polygon) (define MT (empty-scene 50 50)) ; Polygon -> Image ; adds an image of p to MT (define (render-polygon p) (render-line (connect-dots p) (first p) (last p))) ; A NELoP is one of: ; – (cons Posn '()) ; – (cons Posn NELoP) ; NELoP -> Image ; connects the Posns in p in an image (define (connect-dots p) (cond [(empty? (rest p)) MT] [else (render-line (connect-dots (rest p)) (first p) (second p))])) ; Image Posn Posn -> Image ; draws a red line from Posn p to Posn q into im (define (render-line im p q) (scene+line im (posn-x p) (posn-y p) (posn-x q) (posn-y q) "red")) ; Polygon -> Posn ; extracts the last item from p (define (last p) (cond [(empty? (rest (rest (rest p)))) (third p)] [else (last (rest p))]))

In summary, the development of render-poly naturally points us to
consider the general problem of connecting a list of successive dots. We
can then solve the original problem by defining a function that composes
the general function with other auxiliary functions. The program therefore
consists of a relatively straightforward main
function—

Use both ideas to define render-poly; make sure both definitions pass the test cases.

Exercise 187. Modify connect-dots so that it consumes an additional Posn structure to which the last Posn is connected. Then modify render-poly to use this new version of connect-dots. Note This new version is called an accumulator version.

Naturally, functions such as last are available in a language like
Racket and polygon—

### 13` `Extended Exercises: Lists

This chapter presents four extended exercises, all of which aim to solidify your understanding of all elements of design: the design of batch and world programs, the design recipe for functions, making wish lists, and the guidelines for composing functions.

The first problem—

#### 13.1` `Word Games, Composition Illustrated

Sample Problem: Given a word, find (all possible) words that are made up from some letters. For example “cat” also spells “act.”

ader

aedr

aerd

adre

arde

ared

daer

eadr

eard

dare

rade

raed

dear

edar

erad

drae

rdae

read

dera

edra

erda

drea

rdea

reda

A systematic enumeration of all possible arrangements is clearly a task for a program as is the search in an English-language dictionary.This section relies on the 2htp/batch-io library. This section covers the design of the latter, leaving the solution of the second problem to the next section. By separating the two, this first section can focus on the high-level ideas of systematic program design.

; On OS X: (define DICTIONARY-LOCATION "/usr/share/dict/words") ; On LINUX: ; the file 'words' in /usr/share/dict/ or /var/lib/dict/ ; On WINDOWS: ; borrow the word file from one of your Linux or Mac friends (define DICTIONARY-AS-LIST (read-lines DICTIONARY-LOCATION))

Let’s imagine for a moment how we might solve the problem by hand. If you had enough time, you might enumerate all possible arrangements of all letters in a given word and then just pick those variants that also occur in a dictionary. Clearly, a program can proceed in this way too, and this suggests a natural design by composition but, as always, we proceed systematically and start by choosing a data representation for our inputs and outputs.

; String -> List-of-strings ; find all words that the letters of some given word spell (define (alternative-words s) ...)

(check-member-of (alternative-words "cat") (list "act" "cat") (list "cat" "act"))

The first one is about testing. Suppose we had used the word “rat” for which there are three alternatives: “rat,” “tar,” and “art.” In this case, we would have to formulate six lists, each of which might be the result of the function. For a word like “dear” with four possible alternatives, formulating a test would be even harder.

The second problem concerns the choice of word representation. Although String looks natural at first, the examples clarify that some of our functions must view words as sequences of letters, with the possibility of rearranging them at will. It is possible to rearrange the letters within a String, but lists of letters are obviously better suited for this purpose.

To make it all concrete, assume we wish to formulate a test for alternative-words when given "rat". From the above, we know that the result must contain "rat", "tar", and "art", but we cannot know in which order these words show up in the result.

; List-of-strings -> Boolean (define (all-words-from-rat? w) (and (member? "rat" w) (