Function Pointer Challenge

[Jonathan Marler via Digitalmars-d]

In a library I was writing I was in need of the following:
Write code that takes a function pointer/delegate and an array of 
strings that calls the function by parsing each string into the 
given functions arguments.  And if the function has a return 
value, the code will also return the functions return value after 
the call.

I had written this functionality before in .NET (C# specifically) 
using .NET's runtime reflection.  The code looks nice but runtime 
reflection has poor performance.  Using D's compile-time features 
I was able to write a D template function that implemented this 
in about 10 lines of code.

ReturnType!Function call(Function)(Function func, const char[][] 
args...) if (isCallable!Function)
{
  alias Args = ParameterTypeTuple!Function;

  if(args.length != Args.length)
    throw new Exception(format("Expected %d arguments but got 
%d", Args.length, args.length));

  Args argsTuple;

  foreach(i,Arg;Args) {
    argsTuple[i] = to!Arg(args[i]);
  }

  return func(argsTuple);
}

Here's a unit test to demonstrate its usage:

unittest
{
  void voidFunction()
  {
    writeln("[Test] Called voidFunction()");
  }
  void randomFunction(int i, uint u, string s, char c)
  {
    writefln("[Test] Called randomFunction(%s, %s, \"%s\", 
'%s')", i, u, s, c);
  }
  ulong echoUlong(ulong value)
  {
    writefln("[Test] Called echoUlong(%s)", value);
    return value;
  }

 (&voidFunction).call();
 (&randomFunction).call("-1000", "567", "HelloWorld!", "?");

  string passedValue = "123456789";
  ulong returnValue = (&echoUlong).call(passedValue);
  writefln("[Test] echoUlong(%s) = %s", passedValue, returnValue);

  try {
    (&randomFunction).call("wrong number of args");
    assert(0);
  } catch(Exception e) {
    writefln("[Test] Caught %s: '%s'", typeid(e), e.msg);
  }

  writeln("[Test] Success");
}

I think this challenge does a great job in demonstrating D's 
compile-time power. I couldn't think of a way to do this in C 
without doing some type of code generation.  The reason I needed 
this functionality was because I was writing a remote procedure 
call type of library, where the function's being called were 
known at compile time, but the arguments (passed over a socket) 
had to be processed at runtime.  I was wondering if anyone had 
good solutions to this problem in other languages.  I was very 
pleased with the D solution but I predict that solutions in other 
languages are going to be much uglier.