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

Varieties of Data

Varieties of Data

• There are a wide variety of different data type that we use in real life, many of which we have seen implemented in Scheme:

  numbers	numeric information
  booleans	true and false
  symbols	representing symbol information (similar to characterinformation)
  structures	compound data

Mixing and Distinguishing Data

• Sometimes a program has to be able to work with different types of data that may be provided, e.g, numbers, structures, and so on.
• A computer has to be able to recognize when it has been given bad data, e.g., a number when a symbol is appropriate, a number out of acceptable range, etc.


We can express these points using:

A	(make-posn 6 1)		D	2
B 	(make-posn 1 5)		E	3
C	1

Predicates

• A predicate in Scheme is an operation that tells us whether or not a data item is of a particular form.
• Predicates include:
  • number? - true if the value is a number; false if it is not.
  • boolean? - true if the value is a number; false if it is not.
  • symbol? - true if the value is a number; false if it is not.
  • struct? - true if the value is a number; false if it is not.
• Examples:

  (number ? 34)
  >true

Predicates for user-defined structures

• When users define their own structures using define-struct, a predicate that recognizes that class of structures is created as well.
• Example:

  (define-struct posn (x y))
  (define-struct star (last first dob ssn))
  (define-struct airplane (kind max-speed max-load price))

• There are now 3 new predicates:
  • posn? - true if the data is posn structure; false otherwise
  • star? - true if the data is star structure; false otherwise
  • airplane? - true if the data is airplane structure; false otherwise

Exercise

• Evaluate the following expressions:

  (number? (make-posn 2 3))
  (number? (+ 12 10))
  (posn 23 )
  (posn? (make-posn 23 3))
  (star? make-posn 23 3)

Redefining distance-to-0

• A point can be:
  • a number, or
  • a posn structure
• We start by writing the contract, purpose and header:

  ;;distance-to-0
  ;;to compute the distance from a-point to the origin
  (define (distance-to-0 a-point) ...)

• With two different types of data, we need a cond expression to handle two different ways of calculating the distance:

  (define (distance-to-0 a-point)
  	(cond
  		[(number? a-point) ...]
  		[(posn? a-point) ...]))

• For the case, where a-point is a structure, we need a template that will allow us to extract each field:

  (define (distance-to-0 a-point)
  	(cond
  		[(number? a-point) ...]
  		[(posn? a-point) ... (posn-x a-point)...
  			 (posn-y a-point)...]))

• If a-point is just a number, that's the distance we seek. Otherwise , we use our previous expression:

  (define (distance-to-0 a-point)
  	(cond
  		[(number? a-point) a-point]
  		[(posn? a-point)(sqrt
  			(+ (square(posn-x a-point))
  				(square (posn-y a-point))))]))

Another example: Square and Circle

• Imagine that we define two new structures:

  (define-struct square (nw length)
  (define-struct circle (center radius)

• We'll assume that a shape can be either a square or a circle.
• Let's write a program that finds the perimeter for a shape.

Finding the perimeter of a shape

• We start with the following skeleton:

  ;; perimeter : shape --> number
  ;; to compute the perimeter of a-shape
  (define (perimeter a-shape)
  	(cond
  		[(square? a-shape) ...]
  		[ (circle? a-shape) ...]))

• Let's add the templates for both types of structures:

  ;; perimeter : shape --> number
  ;; to compute the perimeter of a-shape
  (define (perimeter a-shape)
  	(cond
  		[(square? a-shape) ... (square-nw a-shape) ... (square-length a-shape) ...]
  		[ (circle? a-shape) ... (circle-center a-shape) ... (circle-radius a-shape ...)]))

• After applying the proper formulae for calculating the areas of a square and circle, we get:

  ;; perimeter : shape --> number
  ;; to compute the perimeter of a-shape
  (define (perimeter a-shape)
  	(cond
  	[(square? a-shape) (* (square-length a-shape) 4)]
  		[ (circle? a-shape) 
  		(* (* 2 (circle-radius a-shape))pi)]))

• Next assignment - write a program that will calculate the area for a shape whether it is a square, rectangle or circle.

Designing Programs for Mixed Data

• The use (or possible use) of mixed data requires that we rethink our design recipe.
• There will be changes to:
  • Data Analysis and Design
  • Template
  • Body

Data Analysis and Design

• We must carefully inspect the problem statement to determine how many "problem objects" exist and what their important attributes are.
• Example:

  (define-struct circle (center radius))
  (define-struct square (nw length))
  ;;A shape is either
  ;;1. a structure: (make-circle p s)
  ;;2. a structure: (make-square p s)
  ;; where p is a position, as a number

Template

• Remember that the template is a translation of the input data definition into Scheme.
• Given that there are more than one possible types of data, we have to use a cond expression to account for what we will do in each case:
• Example:

  (define (f a-shape)
  	(cond
  		[(square? a-shape)
  		... (square-nw a-shape) ...
  			(square-length a-shape)...]
  		[(circle? a-shape)
  			...(circle-center a-shape) ...
  			(circle-radius a-shape)... ]))

Body

• Using the conditional template that we have developed, we split the task into several simpler tasks.
• We can focus on each cond-line separately and ask "what will the output be if we're given this type of data?"

  ;; perimeter : shape --> number
  ;; to compute the perimeter of a-shape
  (define (perimeter a-shape)
  	(cond
  		[(square? a-shape) (*(square-length a-shape) 4)]
  		[(circle? a-shape)
  			(*(*circle-radius a-shape)2)pi)]
  	)
  )

Developing Data Representations

• We may wish to develop data representations in stages, especially when the problem statement mentions several different kinds of objects.
• It is important to remember that it is easier to understand several smaller data definitions than one larger one.
• Example:

  (make-circle p s) ;; p is a posn & s is a number
  (make-square p s) ;; p is a posn & s is a number
  We want to develop a produce that uses shape. The first step is:
  ;; f : shape --> ...
  (define (f a-shape)
  	(cond
  		[(circle? a-shape) ...]
  	 [(square? a-shape) ...] ))

• The most natural second step is to pass the arguments to auxiliary programs that will do the calculations for these individual cases:

  ;; f : shape --> ?
  (define (f a-shape)
   (cond
  	[(circle? a-shape) (f-for-a-circle a-shape)]
  	[(square? a-shape) (f-for-a-square a-shape)]
  	)
  )

• Let's use this method to modify the perimeter program

Changes in the Perimeter Program

;; perimeter : shape --> number
(define (perimeter a-shape)
 (cond
	[(circle? a-shape)(circ-perimeter a-shape)]
	[(square? a-shape) (sq-perimeter a-shape)]
	)
)
;; circ-perimeter : shape --> number
(define (circ-perimeter a-shape)
  (* (* (circle-radius a-shape) 2)pi))
;; sq-perimeter : shape --> number
(define (sq-perimeter a-shape)
  (* (square-length a-shape) 4))

Input Errors

• Let's take another look at our first program:

  ;; area-of-disk : number --> number
  ;; to compute the area of a disk with radius r
  (define (area-of-disk r)
  	(* 3.14 (* r r)))

• What happens if someone enters:

  (area-of-disk 'five)

Checking for Input Errors

• Let's write a version of this program that checks for data of invalid types:

  ;; checked-area-of-disk : number --> number
  (define (checked-area-of-disk v)
  	(cond
  		[(number? v) (area-of-disk v)]
  		[(boolean? v) error 'checked area-of-disk
                      "number expected"]
  		[(symbol? v) error 'checked area-of-disk
                   "number expected"]
  		[(struct? v) error 'checked area-of-disk
                   "number expected"]))

• We can rewrite this program to simplify it:

  (define (checked-area-of-disk v)
  	(cond
  		[(number? v) (area-of-disk v)]
  		[else error 'checked area-of-disk "number expected"]
  	)
  )

[Back to the Notes Index]