Calling arbitrary functions at runtime?

[Kevin Balbas via Digitalmars-d-learn]

I'm writing a system to register functions to be called at 
runtime.  With zero-argument functions, it works fine.  However, 
I run into a problem with functions that take arguments.

This is the relevant code I started with (zero-argument version):

mixin template CommandSystemRegister(string s = __MODULE__)
{
     void CommandSystemRegisterCommands()
     {
         foreach(name; __traits(allMembers, mixin(s)))
         {
             static if (hasUDA!(mixin(name), RegisterCmd))
             {
                 commandTable[name] = &mixin(name);
             }
         }
     }
}

void CommandSystemExecuteCommand(string cmd)
{
     auto result = cmd in commandTable;

     if (result !is null)
     {
         (*result)();
     }
     else
     {
         writefln("command %s not found.", cmd);
     }
}

The way to extend this seemed fairly straightforward.  I did the 
following things:

1.  Wrap function with a Variant, and put that Variant into a 
struct alongside an array of stringified parameter types (because 
Parameters!T can't be stored directly).

2.  On execution, parse the arguments to their correct types.

The problem is, I can't figure out how to actually *call* the 
function.  If it were python, I could construct a tuple with a 
comprehension and unpack that, but I can't figure out any way to 
dynamically construct tuples this way in D.

Basically, I need some way to turn an array of strings into an 
argument list at runtime.  Is this possible?