Re: How to implement dynamic typing?

David Belier <davidbleier@hotmail.com> writes:


> Recently I finished chapter 7 of the dragon book (2nd edition) but I
> still don't understand how to implement dynamic typing. I don't get
> how you are supposed to store the type information with each variable
> and check it every time using an acceptable amount of resources and
> time. Can someone please name papers or websites to read?


Combining each value (not variable) with a type tag is the most common
way to implement dynamic types. If the number of possible types is
fixed at compile time, the tags can be small integers (one for each
possible type) and you would typically test the tag before each
operation (where an operation would only allow a small number of
different types). If you can dynamically create types or add operations
to types, the tag can be a pointer to a descriptor, which itself can be
a table of the possible operations. This is typical for OO languages,
which have dynamic types to some degree (due to dynamic subtyping) even
when they are nominally statically typed (such as Java).


> Note: I have a strong C++ background and know x86 assembler. I can
> imagine a way to implement it doubling memory requirements and making
> the program dead slow in the process so there must be better ways. In
> the past I have also used Java and Python for small programs (CS
> course and writing file converters). They seemed to show reasonable
> performance.


Most Python imlementations are fairly slow, but you will only notice
this if you do intensive calculations.


If you want to make a dynamically-typed language fast, you should
exploit the fact that most programs use only single types for most
variables, so you can do type inference before compilation and add/test
type tags only where the inference can't statically infer a type. This
is called "soft typing" and can also be used as a bug-finding tool
(since the inferencer can find instances where it is certain that a
dynamic type check will fail).


Torben

Return to the comp.compilers page.
Search the comp.compilers archives again.