Tansel, (tansel@rase.com) said:

>There is a big debate about importance of type checking in object
>oriented systems. We have one camp religiously defending type checking,
>and another group defending unnecessity of it. There is a merit in both
>sides� arguments.

Clearly.  Perhaps we can stop bickering long enough to do something 
productive.  How hard could it be to write a type-free interpreter in a 
staticly - typed language?  This would allow static typing where possible
and dynamic binding where truely necessary.

Since any OO-lang already supports inheritance, polymorphism, etc. the 
interpretation proces shouldn't be too hard because it can steal these 
features from the underlying language (hopefully).

Off the top of my head, you'd need a root class for everything (or at least an 
interface), call it "Object", and it would have to support a perform: method.  
This could perhaps be done in C++ most easily since you can pass functions 
around so easily.  In a better language it would be harder, though (e.g. a 
language without crazy unchecked pointers floating around everywhere).

Since the compiler wants to know that a function call is legit at compile 
time, you might have to type in a dictionary of calls to be looked up by 
method name at runtime.  Each call would be statically well-typed, but the 
lookup mechanism could take the method name and args as strings to be checked 
at runtime to see if the method names are in the lookup dictionary (and 
would generate a "does not understand" message if the desired function was not 
there).

The downside to this scheme (if it would work at all) is that it requires us 
to define all methods that might be called via the "perform" hack, above, in 
these dictionaries -- one for each class.

Or is that a FEATURE!?

Maybe someone has something slicker/easier?

>> Regards,
>> -Joachim

>Kindest Regards
>Tansel

Obsequious regards,
Damon