Re: How to call function with variable arguments at runtime?

[Marc Schütz via Digitalmars-d-learn]

On Tuesday, 10 October 2017 at 02:58:45 UTC, Mr. Jonse wrote:
I need to store a hetrogeneous array of delegates. How can I do 
this but still call the function with the appropriate number of 
parameters at run time?

I have the parameters as Variant[] params and a 
function/delegate pointer(void* for now).

Normally I'd push the parameters on the stack and use a call, 
but I'm sure D has some ability to do this, like apply(foo, 
args) would be the same as foo(args[0], ..., args[1]).

I'm not concerned about type correctness, it should always be 
consistent between what I call and what is stored.

Thanks.

Like so?

import std.variant;

void foo(int a, string b, float c) {
    import std.stdio;
    writefln("a = %s, b = %s, c = %s", a, b, c);
}

auto apply(alias fn)(Variant[] values) {
    import std.traits : ParameterTypeTuple;
    import std.conv : emplace;
    alias Types = ParameterTypeTuple!fn;
    assert(values.length == Types.length);
    Types args = void;
    foreach(i, ref arg; args) {
        // using emplace instead of assignment here to be fully 
correct
        emplace!(typeof(arg))(&arg, values[i].get!(typeof(arg)));
    }
    return fn(args);
}

void main() {
    Variant[] values = [Variant(1), Variant("Hello world"), 
Variant(3.14159f)];
    apply!foo(values);
}