CSC 270 - Survey of Programming Languages: Scheme (Racket)

CSC 171 - Compound Data, Part 2: Lists

Lists

Lists are a ubiquitous part of life.
A list is nothing more than a sequence of items.
In scheme, we always start with an empty list and form other lists by add items to the beginning using the cons operator.

Examples:

Empty.
(cons 'mercury empty)
(cons 'Venus (cons 'mercury empty))
(cons ('earth (cons 'Venus (cons 'mercury empty)))

Creating Lists

We can create a list of numbers:

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

A list does not have to consist of all the same data type:

(cons 'RobinRound
  (cons 3
    (cons true
      (empty)))

Constructing a list of 3 numbers is fairly simple:
```
(cons x (cons y (cons z empty)))
```
where x, y and z are numbers.

Extracting Items From a List

Let's say that we want to add up 3 numbers on a list:

;; add-up-3 : list-of-3 --> number
;; to add up the three number in a list-of-3-numbers
;;examples:
;;(add-up-3 (cons 2 (cons 1 (cons 3 empty)))) = 6
;;(add-up-3 (cons 1 (cons 0 (cons 1 empty)))) = 1
(define (add-up-3 a-list-of-3-numbers) ...)

This requires an operator which allows us to extract items from the list:
- first - extracts the item at the beginning of the list
- rest - extracts all the list missing the first item.

First and Rest : Examples

Examples:

(first (cons 10 empty))

= 10

(rest (cons 10 empty ))

= empty


(first (rest (cons 10 (cons 22 empty))))
		= (first (cons 22 empty))

= 22

Exercise

Given the list l:
```
(cons 10 (cons 20 (cons 5 empty)))
```

What are the values of:

(rest l)
(first (rest l))
(rest (rest l))
(first (rest (rest l)))
(rest (rest (rest l)))

Add-up-3 template

Our template for the program add-up-3 becomes:

;; add-up-3 ; list-of-3-numbers --> number
;; to add up the three numbers in a a-list-of-3 ;;numbers
(define (add-up-3 a-list-of-3-numbers)
 ... (first a-list-of-3-numbers) ...
 ... (first (rest a-list-of-3-numbers)) ...
 ... (first (rest (rest a-list-of-3-numbers))) ...)

Lists and structures

There is a similarities between lists and structures.

A list can be said to consist of two fields, left and right where right is always a list.
We could define using:
```
(define-struct pair (left right))
```

The constructor could be written as:

;; cons : any-value cons-or-empty --> a-list
;; a checked version of make-pair
(define (cons any a-list)
	(cond
	[(empty? a-list) (make-pair any a-list)]
	[(pair? a-list) (make-pair any a-list)]
	(else (error 'cons "list as second argument expected"]))

Data Definitions for Lists of Arbitrary Length

Example - creating a toy store's inventory
- We would start with a blank page and write down various items (like dolls, bicycles, baseballs, etc.).
- We can do the same thing in Scheme:
```
empty
(cons 'ball empty)
(cons 'arrow (cons 'ball empty))
(con 'clown (cons 'bow (cons 'arrow (cons 'ball empty))))
```
  and so on

Lists of Arbitrary Size

A real toy store would have a list of inventory items that would grow and shrink; We couldn't assume that we would know all the items that were on its list.
We need a data definition that precisely describes the class of lists that contain an arbitrary number of symbols.
Our definitions all seem to fall into one of two categories:
```
empty
(cons s los)
;; los is a list of symbols
```
Our list will refer to itself in case 2; a list of symbols is define in terms of a list of symbols. This is called self-referential or recursive.

Recursive definitions

A recursive definition defines something in terms of itself with the exception of one (or more) special cases.
In our example, the empty list is the special case that allows our definition to work.

Problem: Is there a doll on our list?

Imagine trying to determine if there is a doll on our list (we can call the program contain-doll?)

We start with our contract header and purpose statement:

;; contains-doll? : list-of-symbols --> boolean
;; to determine whether the symbol 'doll  occurs ;on a-list-of-symbols
(define (contains-doll? a-list-of-symbols) ..)

Let's look at some examples

(contains-doll? empty)

= false


(contains-dolls? cons 'ball empty))

= false


(contains-dolls? cons 'doll empty))

= true


(contains-doll? (cons 'bow (cons 'arrow (cons 'ball empty))))

= false


(contains-doll? (cons 'bow (cons 'arrow (cons 'ball empty))))

= false

Let's look at the two kinds of cases:
- an empty list
- a constructed list

This makes our template:

(define (contains-doll? a-list-of-symbols)
	(cond
	[(empty?) a-list-of-symbols) ...]
	[(cons? a-list-of-symbols) ...]))

or we can use an else clause

(define (contains-doll? a-list-of-symbols)
	(cond
	[(empty?) a-list-of-symbols) ...]
	[else ...]))

Let's remember that a list can be viewed as a structure of an item followed by a list:

(define (contains-doll? a-list-of-symbols)
	(cond
	[(empty?) a-list-of-symbols) ...]
	[else ...(first a-list-of-symbols) ... (rest ...a-list-of-symbols) ...]))

If the list is empty, then contains-doll? must be false.

If the list is not empty and the first item is a doll, then contains-doll? must be true.

define (contains-doll? a-list-of-symbols)
	(cond
	[(empty?) a-list-of-symbols) false]
	[else 
	 (cond
     [(eq? (first a-list-of-symbols) 'doll) true]
     [(rest ...a-list-of-symbols) ...])]))

What if the non-empty list doesn't begin with doll? Let's use a program that can check the remaining list - that program is contains-doll?, the program we already have!

(define (contains-doll? a-list-of-symbols)
	(cond
	[(empty?) a-list-of-symbols) false]
	[else 
	  (cond
      [(eq? (first a-list-of-symbols) 'doll)
             true]
      [(rest a-list-of-symbols)
         (contains-doll? a-list-of-symbols))
      ]
     )
   ]
  )
)

Designing Programs for Self-Referential Data Definitions

Although self-referential data definitions seem fairly complex, our design recipes still work.
Let's take a look at how this affects
- Data analysis and design
- Template
- Program Body
- Combining Values

Data analysis and design

If a problem statements talks in terms of compound data of arbitrary size (it isn't fixed in size), we need a recursive or self-referential data definition. Right now, that means a list.
For a recursive definition to be valid, it must meet two conditions:
- It must contain at least two clauses
- At one canot refer back to the definition.
- Example:
  - A list of symbols is either
```
empty
or (cons s lof) where s is a symbol and lof is a list
```

Template

Since a recursive data definition specifies a mixed collection of data, and one should be a subclass of compound data, we can use our earlier recipes.

We'll use a cond-expression and have one clauses for each type of data on the list:

(define prog-for-los a-list-of-symbols)
	(cond
	  [else ...
         (first a-list-of-symbols)...
	        (rest a-list-of-symbols) ...]
  )
)

Program Body

Let's start with those cases that do contain recursive (or self-referential) definitions. These are often called base cases.
Let's look at the self-referential cases; if the definition is recursive, it may be nearly solved. Otherwise, it may be a matter of combining our values in some obvious (or near-obvious) way.

Let's look at how-many again:

;; how-many : list-of-symbols --> numbers
;; to determine how many symbols are on  a 
;; list-of-symbols
(define (how-many a-list-of-symbols)
  (cond
    [(empty? a-list-of-symbols) ... ]
    [ else ... (first a-list-of-symbols) ...
      ... (how-many (rest-of-symbols)) ...]))

The base case is obviously 0 (there is nothing on an empty list).

The self-referential case is that the list of 1 more than the rest of the list.

;; how-many : list-of-symbols --> numbers
;; to determine how many symbols are on  a 
;; list-of-symbols
(define (how-many a-list-of-symbols)
  (cond
    [(empty? a-list-of-symbols) 0 ]
    [ else (+ (how-many (rest-of-symbols)) 1)]))

Combining Values

In many cases, the combination step uses scheme's primitive operations, e.g., + and and cons.
We can, if necessary, include a nested cond-expression inside if necessary.
Auxiliary programs can also be used wherever necessary.

The Revised Design Recipe

Data Analysis & Design	To formulate a group of data definitions	Develop a data definition for mixed data with at least 2 alternatives, one which can't be self-referential
Contract Header & Purpose	To name the program, to specify its inputs & outputs, to describe its purpose, to formulate a program header	name the program, its input, outputs, and specify its purpose: ;; name : in1 in2.. -> out ; to compute out (define (name x1 x2 ..) ..)
Examples	To characterize the input-output relationship via examples	Create examples of the input-output relationship, with at least one example per alternative.
Template	To formulate an outline for a group of programs	Develop a cond-expression with one clause per alternative One alternative cannot refer to the definition. Have at least one example per alternative
Body	To define the program	Formulate a Scheme expression for each simple cond-line. Explain for all other cond-clauses what each natural recursion will compute. Formulate an answer using selectors, parameters, etc.
Test	To expose mistakes ("typos" and logic)	Apply the program to examples and check against the expected output.

Processing Simple Lists: Another Example

Let's write a program which finds the total of list inventory item costs.

Let's see some examples of inputs:

empty
(cons 1.22 empty)
(cons 2.59 empty)
(cons 1.22 (cons 2.59 empty)
(cons 17.05 (cons 2.59 (cons 1.22 empty)))

We know that our input is:

empty      or 
(cons n lon) where n is a number and lon is a list of numbers

Header, Contract and Examples for Sum

Let's start with our most header and contract:

;; sum : list-of-number --> number
;; to compute the sum of the numbers on 
;; a-list-of-nums
(define (sum a-list-of-nums) ...)

Let's look at some examples:

(sum empty) = 0
(sum (cons 1.00 empty)) = 1.0
(sum (cons 17.05 (cons 1.22 (cons 2.59 empty)))) = 20.86

Writing the program body

Let's add a cond expression to our template:

(define (sum a-list-of-nums)
  (cond
    [(empty? a-list-of-nums) ...]
    [(cons? a-list-of-nums) ...]))

Let's add a selector for each clause:

(define (sum a-list-of-nums)
  (cond
    [(empty? a-list-of-nums) ...]
    [(cons? a-list-of-nums) 
       ...(first a-list-of-nums) ...
        (rest a-list-of-nums)...]))

Let's add a recursive definition of sum to the program:

(define (sum a-list-of-nums)
  (cond
    [(empty? a-list-of-nums) ...]
    [else
       ...(first a-list-of-nums) ...
        (sum(rest a-list-of-nums))...]))

The first operator extract the first item and the second finds the sum of the rest of the list.
How would find the sum of the whole list from these data items?

The expression becomes:

(+ (first a-list-of-nums)
  (sum (rest a-list-of-nums)))

Our program becomes:

(define (sum a-list-of-nums)
  (cond
    [(empty? a-list-of-nums) 0]
    [else
      (+ (first a-list-of-nums)
         (sum (rest a-list-of-nums)))]
   )
 )

[Back to the Notes Index]