Type Conversions

Type Conversions can be

• explicit (casts) if the programmer must write something to cause these conversions,
• implicit (coercions) if done automatically by the compiler.

From the point of view of type checking,

• explicit conversions are just like function applications,
• implicit conversions requires the type checker
  • to detect that the two types are different and
  • to insert the appropriate cast.

Coercions

• occur for instance with overloaded operators (say in C++) or in assignment statements and
• for efficiency reasons should be done at compile time.

Example 1   Let us extend the set of expression constructs of the language from the previous section

• We add a type $\bf real$ for floating point numbers with some fixed precision.
• Elements of this new type must match the pattern $\bf num . num$.
• We also add binary infix arithmetic operators and use $\bf op$ in what follows to denote any of them.
• These new operators are defined over the types $\bf integer$ and $\bf real$.

T $\longmapsto$ $\bf real$

E $\longmapsto$ $\bf num . num$.

E $\longmapsto$ E $\bf op$ E

The translation scheme for these new rules are:

T $\longmapsto$ $\bf real$	{ T.type :=	$\bf real$ }
E $\longmapsto$ $\bf num . num$	{ E.type :=	$\bf real$ }
E $\longmapsto$ E1 $\bf op$ E2	{ E.type :=	if E1.type = $\bf integer$ and E2.type = $\bf integer$
		then $\bf integer$
		elseif E1.type = $\bf real$ and E2.type = $\bf real$
		then $\bf real$
		elseif E1.type = $\bf integer$ and E2.type = $\bf real$
		then $\bf real$
		elseif E1.type = $\bf real$ and E2.type = $\bf integer$
		then $\bf real$
		else $\bf type\_error$ }