Class 31: Data Types (II)

Held Monday, April 19

Summary

• Assignment 5 (Prolog) due.

Contents

Notes

• Assignment 5 is due today.
• Don't forget that you need to create presentation groups by Wednesday. I've yet to hear from from any of you about preferred topics.
• I've rearranged the syllabus slightly. We'll be covering object-oriented programming next. You should read the appropriate chapter in Louden for Wednesday.
• Mr. Walker may be visiting class this week or next. This is the last chance for him to evaluate an upper-level class before my 3rd-year review.

Types, Revisited

• Recall that we've been talking about types and type systems.
• We've found that there are (at least) three ways to think about types:
  • A type describes a set of values.
  • A type describes a collection of operations that can be performed on the values of the type.
  • A type describes restrictions on the parameters to a function.
• If we think about types as sets of values, we might take advantage of some set operations to form new types. These include
  • Subset (including ``same set'').
  • Intersection
  • Union
  • Product (cross). AxB = { <a,b> | a in A, b in B }
  • Power set. 2^A = { B | B is a subset of A }
  • Self-product. Aⁿ = A x A x ... x A (n times).
  • Star (not standard set notation). A* = union (Aⁿ)
• We've looked at some of these in terms of actual types.
  • A record is like a product.
• Are there reasons we'd want to use the others? Are there languages that permit us to do so?

Arrays

• Let's think again about arrays. What set operation are arrays most like?
• We'll note that there are at least two ``kinds'' of arrays.
  • Pascal-like arrays, in which you must specify the indices when you declare the array.
  • Java-like arrays, in which you do not need to specify the indices/size.
• We may find that each corresponds to a different type constructor.

References, Pointers, and Variables

• In many programming languages, we have another kind of ``type constructor'' used to build types: the pointer/reference.
• For example, elements of of the ``pointer to an integer'' type support:
  • Dereference: get the integer.
  • Reference: point to a different integer.
• Note that we might want to make a similar distinction between ``integer'' and ``integer variable''.
  • The latter supports assign while the former does not.
  • This is a somewhat subtle distinction that many have trouble making. However, failure to make this distinction can lead to situations in which you treat integer constants as variables, leading to very strange results. (Yes, there were languages in which you could change the value of 2.)

History

• Created Tuesday, January 19, 1999 as a blank outline.
• Filled in the details on Monday, April 19, 1999.
• Removed uncovered materials on Wednesday, April 21, 1999.