Compiler as dll

[grauzone]

Yigal Chripun wrote:
> Static languages can have Variant/box types that'll give most of the 
> same functionality of dynamic languages. so, instead of instantiating 
> list!(int), list!(string), etc, you can get one list!(Variant)..
> C# provide such a feature with a keyword instead of rellying on templates.

It would be nice if D would be extended to provide all these things. I 
guess the only reason this hasn't been done is the space overhead of 
full RTTI information. (And dynamic method invocation might require a 
lot of hackery to manually copy the method arguments on the stack.)

> The real difference is that static languages have mostly read-only RTTI. 
> (Java provides a very limited capability to reload classes, IIRC)
> a scripting language allows you to manipulate Types and instances at 
> run-time, for example you can add/remove/alter methods in a class and 
> affect all instances of that class, or alter a specific instance of a 
> class. This cannot be done in a static language.

Some static languages allow it to statically add your own methods or 
variables to a foreign class. An example would be AspectJ, which, among 
other things, adds this feature to Java.

This is still not as dynamic as in dynamic type systems, but I wonder if 
you really need more?

There's something similar in current static languages: you can extend 
the global data segment with global variables. Global variables don't 
have to be all in a single source file. Instead, the linker takes care 
of collecting global variables from object files and allocating space 
for them in the data segment. A dynamic linker can do this even while a 
program is running!

Thread local storage (with global __thread variables) does the same 
thing per thread. Threads can be created and destroyed at runtime. 
Dynamic linking is still supported, I think.