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

Compound Data I: Structures

Compound Data

Programs rarely use a single input, whether it is a number (integer or real), a logical value (True or False), or a name (a symbol).
In most cases, computer programs group related data together because they refer to a common entity, e.g., a person's personnel record will contain date of birth, salary, name, social security number, etc.
Scheme provides several ways to group data, including the most commonly used: the structure.

Positions of Pixels

A pixel (short for picture element) is one of the many dots on a computer screen. Each one has an x and y coordinate, which together specify its position on the screen.
Dr Scheme provides a library that allows us to draw on the screen (which requires us to be able to specify coordinates. We use the operation make-posn
```
(make-posn 3 4)
(make-posn 8 6)
(make-posn 5 12)
```
These are posn structures, which have the same status in a Scheme program as 5, 34, etc.

Example - Calculating distance from the origin

We want to write a program to calculate the distance from the origin (0,0). We start with:

;; distance-to-0 : posn --> number
;;to compute the distance of a-posn to the origin
(define (distance-to-0 a-posn) ...)

This is easy to calculate for points on the x-axis or y-axis:

(distance-to-0 (make-posn 0 5)) =  5
(distance-to-0 (make-posn 7 0)) = 7

In general, the distance for a point with coordinates (x, y) is:
```
	(x² + y²)^1/2
```

Using this formula, we would get:

(distance-to-0 (make-posn 3 4)) =  5
(distance-to-0 (make-posn 8 6)) = 10
(distance-to-0 (make-posn 5 12)) = 13

To calculate this distance, we need to work with x and y as well as (x, y).

Dr. Scheme provides us with operations for this purpose:

posn-x (which returns the x coordinate)
posn-y (which returns the y coordinate)

e.g.,

(posn-x (make-posn 7 0)) = 7
(posn-y (make-posn 0 5)) = 5

Defining a structure's value

We can define a value for a structure:

(define a-posn (make-posn 7 0))
(posn-x a-posn) = 7
(posn-y a-posn) = 0

We cam nest expressions:

(+ (posn-y a-posn) 13
(+ (posn-x a-posn) (posn-y a-posn))
(+ (* (posn-x a-posn) (posn-x a-posn))
	 (* (posn-y a-posn) (posn-y a-posn)))

Given this, we can now write the body of our program:

(define (distance-to-0 a-posn)
	(sqrt
			(+ (square (posn-x a-posn))
			   (square (posn-y a-posn)))))

Defining the square of x

The Square of x is simply x*x.
Since the value being passed is either the x-coordinate or the y-coordinate, the function square receives an integer value:
```
(define (square x) (*x x))
```

Exercise

Dr Scheme provides a library (or in newer versions a Teach Package) called draw-lib.ss

Use it and evaluate:

(distance-to-0 (make-posn 3 4))
(distance-to-0 (make-posn (*2 3) (*2 4)))
(distance-to-0 (make-posn 12 (-6 1)))

Dr Scheme provides the following graphics operations:

draw-solid-line
draw-solid-rect
draw-solid-disk
draw-circle

Evaluate the following expressions:

(start 300 300)
(draw-solid-line (make-posn 10 10) (make-posn 10 200) 'green)
(draw-solid-rect (make-posn 20 10) 50 200 'blue)
(draw-solid-disk (make-posn 200 10) 50 'red)
(stop)

Structure Definitions

A structure is a collection of data that collectively represent something, e.g., point's coordinates, a customer's purchase, an employee's record, etc.
Scheme defined the structure posn:
```
(define-struct posn (x y))
```

In defining a position in this manner, we also used 3 operations:

make-posn	-	creates posn structures
posn-x	-	extracts the x-coordinate
posn-y 	-	extracts the y-coordinate

Defining a Structure

Let's define a class of structures that define a point in space:
```
(define-struct point (x y z))
```
The structure point has three fields: x, y & z.
Our constructor is used to create a structure out of values for these three fields:
```
(make-point 3 4 5)
```

If we wished to extract the values of each coordinate we could do that as well:

(point-x (make-point 3 4 5)) = 3
(point-y (make-point 3 4 5)) = 4
(point-z (make-point 3 4 5)) = 5

Defining a Structure - An Example

Example - we manage several rock stars and we want to keep track of our data about them. We could write:

(define-struct star (last first instrument sales))

To create records for our initial clients, we would write:

(make-star 'Friedman 'Dan 'ukelele 19004)
(make-star 'Talcott 'Carolyn 'banjo 80000)
(make-star 'Harper 'Robert 'bagpipe 27860)

If we have a star structure named "E" , we could use:
```
(star-first E)
```
to get his first name.
The operators star-last, star-instrument and star-sales would be used to extract the other values stored in the structure.

Consuming and Producing Structures

Programs can and will consume and produce structures.

Example: One of our rock-stars sees his sales increase by 20000.

First let's write the basic description of the program:

;;increment-sales : sales --> sales
;; to produce a star record like a-star ;;with 20000 more sales
(define (increment-sales a-star) ...)

An example of its use:

(increment-sales (make-star 'Abba 'John 'vocals 12200))

Our algorithm is to create a new record with the same last name, first name, instrument but sales are the old sales + 20000.

;; increment-sales star --> sales
;; to produce a star record like a-star with 20000 ;; more sales
(define (increment-sales a-star)
	(make-star (star-last a-star)
	(make-star (star-first a-star)
	(make-star (star-instrument a-star)
	(make-star (+ (star-sales a-star) 20000)))

Data Definitions

Imagine the following expressions:
```
(make-posn 'Albert 'Meyer)
(define (square x)
  (* x x))

(sqrt
 (+ (square (posn-x (make-posn 'Albert 'Meyer)))
    (square (posn-y (make-posn 'Albert 'Meyer)))))
```
- The result is to try to find the square of two symbols and then add them.
- This produces a run-time error, because they are not numbers.

A data definition combines English and Scheme to tell the user how we plan to use the data contained in the definition:

;; posn is a structure
(make-posn x y)
;; where x and y are numbers.

;;star is a structure
(make-star last first instrument sales)
;;where last, first and instrument are 
;;symbols and sales is a number.

Designing Programs for Compound Data

It's important to think of the data that belongs to an object as one piece of information even if it has several pieces.
- Scheme lets us do this by defining structures.
It becomes important to modify the basic design recipe to accommodate the ways in which we develop programs so that we can design programs to use structures correctly and wisely.

Data Analysis and Design

We must understand how to represent information in our problem before we can develop a program.
This requires the definition of structures that handle data in the way that our problems use them.
E. g., a program that processes student records. A student's attributes which may be of interest might be:
- First name
- Last name
- Name of the homeroom teacher
Our record definition becomes:
```
(define -struct student (last first teacher))
```
We could create a student record by writing
```
(make-student 'findler 'kathy 'matthias)
```

Writing the Contract

We can use the names of Scheme's built-in data, such as number symbol and names introduced in the structure definition when writing the contract.

Writing the Template

Since a program consume compound data is likely to use the structure components, we start by designing a template that includes all possible selector expression.

E. g.,

;; process-student : student symbol --> ???
(define (process-student a-student a-teacher)
	... (student-first a-student)...
	... (student-last a-student)...
	... (student-teacher a-student)...

Writing the Body

Once we have the template, we can design the body.
This design's goal is to formulate an expression that computes the desired answer based on the available data.

E. g.,

;; process-student : student symbol -- > symbol
(define (process-student a-student -ateacher)
	(cond
		[(eq? (student-teacher a-student) a-teacher)
			(student-last a-student)]
		[else 'none]))

Revised Design Recipe for Compound Data

Phase	Goal	Activity
Data Analysis & Design	To formulate a group of data definitions	Determine how many pieces of data describe important parts of the problem - then add a structure definition and a data definition
Contract Header & Purpose	Specify program name, inputs & outputs, and purpose, and write a program header	Name the program, inputs, outputs, and specify its purpose.
Examples	Characterize the input/output relationship via examples	Search the program for examples, validate these examples.
Template	Formulate an outline for a groups of programs	Where parameters stand for compounds values, place selector expressions in the program. If the program is conditional, place selectors in each branch.
Body	To define the program	Develop a Scheme expression that uses Scheme's primitive operation, other programs selector expressions and variables
Test	To expose mistakes	Apply the program to the inputs of the examples, check that the outputs are as predicted.

An example of the Design Recipe

Data Analysis & Definitions

(define-struct student (last first teacher))
;; A student is a structure
;; (make-student f l t)
; where f, l , and t are symbols

Contract

;;Subst-teacher : student symbol --> student

Purpose

;; Purpose - to create a student structure with a 
new teacher name if the teacher's name matches 'Fritz

Examples

(subst-teacher (make-student 'Find 'Matthew 'Fritz) 'Elise)
			=  (make-student 'Find 'Matthew 'Elise)
(subst-teacher (make-student 'Find 'Matthew 'Amanda) 'Elise)
			=  (make-student 'Find 'Matthew 'Amanda)

Template

(define (process-student a-student a-teacher)
		...	(student-first a-student) ...
		... 	(student-last a-student) ...
		...	(student-teacher a-student) ...

Definition

(define (subst-teacher a-student a-teacher)
		(cond
		[(eq? (student-teacher a-student) 'Fritz)
		(make-student (student-last a-student)
                 (student-first a-student)
                 a-teacher)]
   [else a-student]))

Tests

(subst-teacher (make-student 'Find 'Matthew 'Fritz) 'Elise)
			=  (make-student 'Find 'Matthew 'Elise)
(subst-teacher (make-student 'Find 'Matthew 'Amanda) 'Elise)
			=  (make-student 'Find 'Matthew 'Amanda)

[Back to the Notes Index]