Contents:

1. MORE TYPES
   1. Mappings
      1. Arrays
      2. Function abstractions
   2. Powerset
   3. Recursive types
   4. Sequence:
      1. Lists
      2. sequential files
      3. strings:
   1. User-Defined Types
2. STATIC VERSUS DYNAMIC TYPING
3. TYPES IN HISTORY OF PROGRAMMING LANGUAGES
   1. FORTRAN
   2. ALGOL 60
   3. Pascal
      1. Pascal's Types
         1. Built-In:
         2. Enumeration types.
         3. Subranges
         4. Arrays
         5. Variant records
         6. Pointers
         7. Sets
         8. Sequential files
      2. Problems with Types in Pascal
         1. Name EquivalenceA
         2. Name Equivalence (called declaration equivalence in text)
         3. Structural Equivalence
   4. Ada
      1. Ada's Types
         1. Built-In:
         2. Enumeration types.
         3. Subranges
         4. Arrays

Mappings:

Arrays:

Function abstractions:

• What if S were a record instead of an n-tuple?

What is difference from an array? Efficiency, esp. w/update.

	update f arg result x = if x = arg then result else f x

	update f arg result = fn x => if x = arg then result else f x

Powerset:

	set of elt_type;

Operations and relations: All typical set ops, :=, =, subset, .. in ..

Why need base set to be primitive type? What if base set records?

Recursive types:

  	tree = Empty | Mktree of int * tree * tree

	list = Nil | Cons of int * list

Sometimes supported by language (e.g. Miranda, Haskell, ML).

Why can't we have direct recursive types in ordinary imperative languages?

OK if use ref's:

	list = POINTER TO RECORD
			first:integer;
			rest: list
		END;

Recursive types may have many sol'ns

E.g. list = {Nil} union (int x list) has following sol'ns:

1. finite sequences of integers followed by Nil: e.g., (2,(5,Nil))

2. finite or infinite sequences, where if finite then end with Nil

Theoretical result: Recursive equations always have a least solution - though infinite set if real recursion.

Can get via finite approximation. I.e.,

   list0 = {Nil}

   list1 = {Nil} union (int x list0) 
         = {Nil} union {(n, Nil) | n in int}

   list2 = {Nil} union (int x list1) 
         = {Nil} union {(n, Nil) | n in  int}
                 union {(m,(n, Nil)) | m, n in int}

      ...

   list = Unionn listn

	fact = fun n => if n = 0 then 1 else n * fact (n-1)
	
	fact0 = fun n => if n = 0 then 1 else undef
	
	fact1 = fun n => if n = 0 then 1 else n * fact0(n-1)
	      = fun n => if n = 0, 1 then 1 else undef
	      
	fact2 = fun n => if n = 0 then 1 else n * fact1(n-1)
	      = fun n => if n = 0, 1 then 1 else 
	                 if n = 2 then 2 else undef
	...


	fact = Unionn factn

	datatype univ = Base of int | Func of (univ -> univ);

Sequence:

Lists

operations: hd, tail, cons, length, etc.

sequential files

Persistent data - files.

strings:

Are strings primitive or composite?

• Composite (arrays) in Pascal, Modula-2, ...

• Primitive in ML

• Lists in Miranda and Prolog: provides more flexibility (no length bound)

User-Defined Types

1. more readable

2. Easy to modify if localized

3. Factorization - why copy same complex def. over and over (possibly making mistakes)

4. Added consistency checking in many cases.

STATIC VERSUS DYNAMIC TYPING

	var x : integer  {bound at translation time}

FORTRAN has implicit declaration using naming conventions

• If start with "I" to "N", then integer, otherwise real.

In either case, run real danger of problems due to typos.

Example in ML, if

	datatype Stack ::= Nil | Push of int;

	fun f Push 7 = ...

Answer: Push is taken as a parameter name, not a constructor.
Therefore f is given type: A -> int -> B rather than the expected: Stack -> B

Dynamic: Variables typically do not have a declared type. Type of value may vary during run-time. Esp. useful w/ heterogeneous lists, etc. (LISP/SCHEME).

Dynamic more flexible, but more overhead since must check type before performing operations (therefore must store tag w/ value).

Dynamic binding found in APL and LISP.

• Type of variable may change during execution.

• E.g., may have x := 0 at one point and x := [5,2,3] at some other point, yet x is only declared once.

TYPES IN HISTORY OF PROGRAMMING LANGUAGES

FORTRAN

no characters or strings, no user-defined of any sort.

Arrays - at most 3-dim'l of built-in type. Subscripts begin at 1

Orig., restricted form of subscript expressions.

No records or sets. Many holes in typing.

ALGOL 60

Arrays of built-in types - no limit on dim'n, bounds any integers, semi-dynamic arrays

No records or sets. Strongly and statically typed.

Pascal

Pascal's Types

Built-In:

Enumeration types.

Subranges

Arrays

	Array [1..10, 'a'..'z'] of Real = Array [1..10] of Array ['a'..'z'] of Real
	

Any discrete type as index.

No semi-dynamic arrays. Result of 2 principles:

1. All types must be determinable at compile time.

2. Array bounds are part of type.

Type of actual parameters must agree w/ type of formals

Therefore, no general sort routines, etc.

The major problem with Pascal

Variant records

Pointers

Sets

Sequential files

Problems with Types in Pascal

		Procedure x(...; procedure y;...)

			:

			y(a,2);

No checking if type of file read in matches what was originally written.

2. Problems w/ type compatibility

Assignment compatibility:

When is x := y legal? x : integer, y : 1..10? reverse?

What if type hex = 0..15; ounces = 0..15;

var x : hex; y : ounces;

Is x := y legal?

Original report said both sides must have identical types.

When are types identical?

Ex.:

    Type    T = Array [1..10] of Integer;
    Var  A, B : Array [1..10] of Integer;
             C : Array [1..10] of Integer;
             D : T;
             E : T;

Name Equivalence_A

Name Equivalence (called declaration equivalence in text)

--> A, B and D, E only.

Structural Equivalence

Structural not always easy. Let

   T1 = record a : integer; b : real  end; 
   T2 = record c : integer; d : real  end;
   T3 = record b : real; a : integer  end;

Worse:

   T = record info : integer; next : ^T  end; 
   U = record info : integer; next : ^V  end; 
   V = record info : integer; next : ^U  end; 

Ada uses Name Equivalence_A

Pascal & Modula-2 use Name Equivalence for most part. Check!

Modula-3 uses Structural Equivalence

Two types are assignment compatible iff

1. have equivalent types or

2. one subrange of other or

3. both subranges of same base type.

Ada

Ada's Types

Built-In:

Enumeration types.

e.g., type Boolean is (False, True)

Can overload values:

    Color is (Red, Blue, Green)
    Mood is (Happy, Blue, Mellow)

    Color(Blue), Mood(Blue)

i.e., Hex is range 0..15

Other attributes available to modify type definitions:

	Accurate is digits 20
	Money is delta 0.01 range 0.00 .. 1000.00     -- fixed pt!

	Hex'FIRST -> 1
	Hex'LAST  -> 15

	declare k : integer := 0

Arrays

	type Two_D is array (1..10, 'a'..'z') of Real 

	type Real_Vec is array (INTEGER range <>) of REAL;

Of course, to use, must specify bounds,

	declare x : Real_Vec (1..10)

   Procedure sort (Y: in out Real_Vec; N: integer) is -- Y is open array parameter
      Temp1 : Real_Vec(1..N);             -- depends on N
      Temp2 : Real_Vec (Y'FIRST..Y'LAST); -- depends on parameter Y
      begin 
         for I in Y'FIRST ..Y'LAST loop
            ...
         end loop;
         ... 
      end sort;

All unconstrained types (w/ parameters) elaborated at block entry (semi-dynamic)

String type is predefined open array of chars:

	array (POSITIVE range <>) of character;

Can take slice of 1-dim'l array.

E.g., if

    Line : string(1..80)

    Line(10..20) := ('a','b',.'c','d','e','f','g','h','i','j')  
                                         -- gives assignment to slice