Emulating DLL

[Craig]

Is it possible to create a D module that has functions in it, and 
then use those functions dynamically at run time emulating DLL 
like functionality?

e.g.,

module MyDL;

import Context;
export void foo(Context)
{
    ...
}

and

module UseDL;
import DL;
import Context;

void main()
{
     DL.Load("MyDL.dl");
     DL.foo(new Context);
     DL.Unload();

     // or
     DL.Loadable("MyDL.dl"); // monitors changes and reloads the 
function safely  when a change is detected. This might require 
some work to make safe.
     DL.foo(new Context);
     DL.Unload();
}


(pseudo)

The idea here is to simply be able to call external code that can 
be hotswapped and such. It requires dealing with relocatable 
code, GC, etc.


It would be portable and non-windows specific and just work.

dmd and ldc of course do not output anything that is reasonable 
as they use the traditional non-portable formats. This leads me 
to think that without modifying them, I'd have to extract the 
code from the DLL/SO and deal with all the problems and then 
generate the .dl file.

The idea is to create simple way to "script" D programs and use 
the D compiler to compile the functionality. It won't be as fast 
as an interpreter but it will have full speed.

I'm just not sure what would be the best way to generate the code 
and do the fixing up.

I'd be willing to hack on the dmd compiler to try and get it to 
generate a more sane file for this process if someone could point 
me to some details.