[ L01 L02 L03 L04 L05 L06 L07 L08 L09 L10 L11 L12 L13 L14 L15 L16 L17 L18 L19 L20 L21 L22 L23 ]

Lecture 06—Arbitrary-sized data, self reference, and natural recursion

Before Lecture

At this point in the course, you are responsible for everything in the following edX modules: Welcome to 110, BSL, HtDF, HtDD, HtDW and Compound. (That includes videos, online questions, practice problems, lecture problems, lecture discussion.)

To prepare for this lecture, please work through: Introduction to Arbitrary sized data and List Mechanisms in the Self-Reference module on edX. Be sure to solve all the online questions, since one of them may be our clicker question.

During Lecture

One of the things that makes computers useful is their ability to operate on large amounts of information. But up to this point in the course all of our data definitions have described data of fixed size. That changes in this lecture.

By the end of the lecture—including the post-lecture work—you should be able to:

Identify information of arbitrary-size.
Design data definitions using lists of primitive atomic data.
Explain what makes a self-referential data definition well formed.
Identify the base case, contribution, combination, and natural recursion in a template for that data.
Design functions operating on that data.

The starters for this lecture are:

After Lecture

Here are the solutions for this lecture:

Wow! That was pretty interesting.

Self-reference and natural recursion is perhaps the most interesting part of the course. We will keep using these techniques throughout the rest of the course.

Below are some notes that can help you master this material. It is crucial that you do so—in the next lecture, we will do a world program with lists!

First, note that what we have been learning about templating really helps us. Because even though recursion may seem a bit confusing at first, by following the revised recipe it turns out to be fairly easy to write a working recursive function. The template already has the recursion we need in the natural place for it.

You should review the recipe pages, but the recipe revisions, in short, are:

In HtDD: if you need to represent arbitrary sized data you must use a well-formed self-referential type comment.
In data driven template rules: wherever there is a self-reference in the type comment, add a natural recursion to the template.
In HtDF, when designing a function that consumes arbitrary-sized data: the first test should be for the base case, and
there should be at least one test on data that is >= 2 long.
At the moment you copy the template and rename the function, also fix the name in the natural recursion right away.
Always trust the natural recursion. Really trusting it is hard, but once once you do, then you will be using the more sophisticated way of thinking about recursive functions. It is the only approach that will scale to the problems we do later in the term.

The reason you can trust the natural recursion is that the type comments and template rules are based on type theory, so the natural recursions are theoretically sound. This is how designers and engineers often work, they know that a theoretical result makes a certain way of thinking about the problem sound and then they work that way. This is thus software engineering based on results in programming language research.

BUT... you might want to "look inside" at the recursion a little bit right now. If so, put the following into a Racket tab, select the BSL language, and use the Stepper button to see how it runs.

(define (sum lon) 
  (cond [(empty? lon) 0] 
        [else 
         (+ (first lon) 
            (sum (rest lon)))]))

(sum (cons 1 (cons 2 (cons 3 empty))))

While that will show you how the recursion runs, we want to stress that the more sophisticated way of thinking about it is to consider one call to the function, trust the natural recursion to produce the correct result, and then work out what the function should do with that result.

To review:

Work through the units of the Self-Reference module. The first 5 cover the same ground as covered in the lecture, but go into some important points in more detail.
Work through the "Designing with Lists" unit carefully. This is a chance to really solidify your understanding of functions that operate on lists.
The "Positions in List Templates" unit will give you a clearer sense of what's common among the list functions we write and set us up to talk about some very powerful techniques later in the course.
As always, work the practice problems in the module (Self-Reference) and re-work our own problems from class!

Be sure to complete the before lecture section of Lecture 7 before that lecture.