Survey of Common Types I

1
Survey of Common Types I

• Records
• E.g., structs in C
• If elements are named, a record is projected into
  its fields (e.g., via struct member selection
  operator as in P.x in C)
• Variant records (e.g., unions in C) let
  different types overlap in memory
• Arrays
• Usually contiguous in memory and of a homogeneous
  type
• Layout and access patterns also may affect cache
  effects, etc.
• Provide an indexing operator (e.g., ) to access
  elements
• May be allocated on stack or heap (language
  specific)
• May be compatible with other types (e.g.,
  pointers in C)

2
Survey of Common Types II

• Utility types (e.g., strings, sets, lists,
  files)
• Widely used but not necessarily inherent to a
  language itself
• Sometimes built into the language (e.g., Pascal)
• E.g., set operators (, , -) for union,
  intersection, and difference
• Sometimes provided by a library (e.g., the C
  STL)
• Strings
• Often just an array of characters (e.g., C style
  char )
• Often an object with operators (e.g., C style
  string)
• Sets (similarly, lists)
• Contain unique values (or in the case of lists,
  ordered sequences) of a common type
• Files
• Streams of data coming from and/or going to
  mass storage

3
Survey of Common Types III

• Recursive types
• May contain (an alias for) another instance of
  the same type
• E.g., a list node contains an alias for the next
  node in the list
• May require a pointer or other similar
  abstraction
• To halt the nesting (and/or construction) of
  recursive type instances
• Pointers and references
• Similar in some languages, different in others
• E.g., pointer/references semantics in Java vs.
  C
• Also may be similar to other types
• E.g., (const) pointer and array semantics in C
• E.g., address arithmetic vs. index arithmetic in
  C

4
More about Type Constructors

• Used to construct sets from other sets
• E.g., as Cartesian products (tuples)
• If elements are named, a record is projected into
  its fields (e.g., via struct member selection
  operator as in P.x in C)
• Specialized forms of type constructors are common
• Unions often are at best unnecessary in
  object-oriented languages (or worse in C
  certain examples can exhibit type problems
  similar to those seen with reinterpret casting)
• Subset type constructors narrow a set (e.g., in
  Ada to construct a sub-range type from a range
  type)
• Array constructors project an index type into
  another type
• Pointer/reference constructors create aliases for
  other types (pointers have their own operators
  but references do not)

5
Type Checking with Polymorphism

• Hindley-Milner type checking
• Strongly typed functional languages (ML and
  Haskell) do this
• Unambiguous (deductive) type inference, by
  propagating constraints and info up and down an
  abstract parse tree
• Relies on specific forms of instantiation and
  unification
• Different types of polymorphism
• Parametric (interface) polymorphism
• Explicit subtype (inheritance) polymorphism
• Liskov substitution principle whenever S is a
  subtype of T, wherever you need an instance of T
  you can use one of S
• Occurs-check in unification
• Makes sure a variable isnt in an expression
  substituted for it
• Difficult to do efficiently, only use if
  necessary (it is for H-M)

6
Explicit Polymorphism of Data

• Relies on syntax to declare forms of polymorphism
  that cannot be handled implicitly as in previous
  cases
• E.g., declaring polymorphic data structures
• Essentially, they provide user-defined type
  constructors
• E.g., in C/C function pointer and array
  typedefs
• Explicit parametric polymorphism
• Explicit declaration of type parameters (e.g.,
  C templates) can be used to make data types
  generic over other types
• In C calls to function templates are resolved
  implicitly but template objects require concrete
  type parameter declaration
• Expressions within parameterized
  functions/methods impose constraints on the
  parameterized types (concept/models relation in
  generic programming, see Austern on C STL)

7
Todays Studio Exercises

• Well code up ideas from Scott Chapter 7.3-7.9,
  7.11
• Continuing our exploration of data types from
  last time
• Todays exercises are again in C
• C allows us to explore many type system issues
• Please take advantage of the on-line tutorial and
  reference manual pages that are linked on the
  course web site
• As always, please ask us for help as needed
• When done, email your answers with Data Types
  Studio II in the subject line, to the course
  account
• Send to cse425_at_seas.wustl.edu