var dummy : symbol_table_index;
...
dummy := insert_in_symbol_table(bar);

foo_index = insert_in_symbol_table(foo);
...
(void) insert_in_symbol_table(bar); 
/*better yet, casting is implied if omitted */

• Boolean type. true/false. Often implemented with a whole byte with value 1 or 0.
• Character Type. Might be implemented with a particular encoding in mind such as ASCII (single byte) or Unicode UTF-8 (multi-byte).
• Numeric Type. int, float, etc in C/Java/etc. These may or may not come in different precisions, signed or unsigned versions. Some languages support rationals (pairs of integers defining a fraction) or complex numbers.
• Enumeration Types These consist of a set of named elements. For example, enum's in C or Rust:

  enum suit {CLUBS, DIAMONDS, HEARTS, SPADES} suit_test;
  

  In C, the enums are implemented as int's that increase in the order of the enum. So DIAMONDS has value 1.
• Subrange Types. These are types whose values compose a contiguous subset of the values of some discrete base type. A slice in Rust is an example of this:

  let a = [1,2,3,4,5];
  let two_three = &a[1..2];
  

• Composite Types. these are types that are built from simpler types. On the next slide, we'll look at ways to do this.

• Records These consist of a collection of fields where each field is of some simpler type. Records first appeared in COBOL in the 1960s. Rust and C struct are examples. Tuples, Cartesian product types, are special cases of records where the fields have names 0, 1, 2, .... Written formally, given types `T_1, T_2 ... T_n`, their Cartesian product type is `T_1 times T_2 times cdots times T_n` and consists of elements `(t_1, t_2, ..., t_n)` where `t_i in T_i`.
• Variant Records These are records in which only one of the field types is valid at a time. Formally, these are called is a union type or sum type. Given types `T_1, T_2 ... T_n`, the sum type is `T_1 + T_2 +cdots +T_n` and consists of element `t` where `t` is in some `T_i`. The union type of Rust and C are example of this type in particular languages.
• Arrays. These can be thought of as a type `\i\n\t -> T` for some type T. In many languages (C/Rust/Java) we write a[i] to get the `i`th element out of an array. Strings are often implemented as an array of characters.
• Sets. A set type is the mathematical powerset `P(T)` of its base type `T`, . I.e., `{s_1, ..., s_j} in P(T)` if each `s_i` is in `T`. They were first introduced in Pascal. Also appears in Python.
• Pointers are `l`-values for some type `T`. A pointer value is a reference to an object of the pointer's base type. We might write `& T` for the set of values `&t` such that `t in T`. A type is recursive if an object of type T may contain one or more references to other objects of type T.
• Lists are a special kind of recursive type that is usually defined inductively:

  type list T =
    | Nil  : list T
    | Cons : hd:T -> tl:list T -> list T
  

  I.e., the type of list T consists of the elements the empty list Nil as well as elements cons(hd, tl) where hd in T and tl is in list T. Lists are common in functional languages like Scheme. The above ML-like declaration could be implemented in Rust as:

  enum List<T> {
     Nil,
     Cons(T, Box<List<T>>)
  }
  

• Files. File types are intended to represent data on mass-storage devices, outside the memory in which other program objects reside. Like arrays, most files can be conceptualized as a function that maps members of an index type (generally integer) to members of a component type. Unlike arrays, files usually have a notion of current position, which allows the index to be implied implicitly in consecutive operations.

struct __attribute__ ((__packed__)) element { 
   char name[2];
   int atomic_number; 
   double atomic_weight;
   _Bool metallic;
} s;

int a[3][4] = {  
   {0, 1, 2, 3} ,
   {4, 5, 6, 7} , 
   {8, 9, 10, 11}
};

1. Structural Equivalence: two types are the same if they consist of the same components, or put together in the same way.
2. Name Equivalence two types are the same if they have been given the same name when there were defined.

type R1 = record
       a, b : integer
end;

type R2 = record
       a : integer;
       b : integer
   end;

type R3 = record
       b : integer;
       a : integer
   end;

type str = array [1..10] of char;
type str = array [0..9] of char;

type student = record 
   name, address : string
   age : integer
   end;
type school = record 
   name, address : string 
   age : integer
   end;
x : student;
y : school;

...
x := y; //can we make a school a student?

typedef old_type new_type;

type celsius_temp = real; 
type fahrenheit_temp = real;
var  c : celsius_temp;
     f : fahrenheit_temp;
...
f := c; (* this should probably be an error *)

subtype mode_t is integer range 0..2**16-1;
...
type celsius_temp is new integer;
type fahrenheit_temp is new integer;

a := expression // expect a to be of same type as expression
a + b // we expect the types of a and b to be 
      // such that adding makes sense
foo(arg_1, ..., arg_n) //we expect types of arg_i to be 
   // those of the parameters of foo.

int n = (int) b;

1. The types would be considered structurally equivalent, but the language uses name equivalence. So here the conversion doesn't actually involve a change of the underlying data.
2. The types have different sets of values, but the intersecting values are represented in the same way. For example, converting an integer to a sub-range of integer. Conversion in the case might involve doing a run-time check that the integer is in the given range.
3. The types have different low-level representations, but we can nonetheless de- fine some sort of correspondence among their values. For example, converting a signed integer in 1's complement to a float in IEEE 754.