Languages that provide polymorphism tend to place restrictions on
object representations, separate compilation, and/or performance.  For
instance, most Ada implementations require that polymorphism be
resolved before compilation.  Consequently, separate compilation is
sacrificed, since eliminating polymorphism is a cross-module
transformation.  Some languages, like C++ and Modula-3, restrict the
representations of polymorphic objects to "pointer" types.  These
languages provide good separate compilation but restrict programmers
from writing certain types of polymorphic code.  In addition, some
runtime overhead might be paid due to the extra pointer indirection.
Languages such as Scheme, Lisp, SML, and Haskell, place no explicit
restrictions on the representations of objects.  However, almost all
implementations use the "pointer" restriction to implement the
polymorphic features.  In fact, most implementations make every object
a pointer.  This allows the languages to support very flexible forms
of polymorphism and separate compilation.  However, the performance of
such languages suffers due to the space and time overheads introduced
by the indirection.

The goal of this work is to show that polymorphic languages can be
implemented without restrictions on object representations or separate
compilation.  Furthermore, by lifting these restrictions, programmers
and compilers can choose representations that lead to superior
performance.