On 2/5/23 17:20, John Chapman wrote:

> staticMap's "fun" can only be
> instantiated with a single argument, while I need it to work with two.

I adapted staticMap's implementation to two sets of arguments:

import std.meta : AliasSeq;

// The first half of 'args' is the "first arguments" and
// the second half is the "second arguments".
//
// (This can be generalized to N sets of arguments.)
template staticMap2(alias fun, args...)
{
    alias firsts = args[0 .. $ / 2];
    alias seconds = args[$ / 2 .. $];

    static assert(firsts.length == seconds.length,
                  "Mismatched number of first and second arguments");

    alias staticMap2 = AliasSeq!();
    static foreach (i; 0 .. firsts.length) {
        staticMap2 = AliasSeq!(staticMap2, fun!(firsts[i], seconds[i]));
    }
}

// An example struct with two template parameters
struct S(T, size_t length) {
}

// An example template that creates instantiations of the S template
// (This can be generalized to instantiation of any template.)
template Instantiate(T, size_t length) {
    alias Instantiate = S!(T, length);
}

// An example use
alias myTypes = AliasSeq!(int, double, long);
alias mySizes = AliasSeq!(1, 2, 3);
alias result = staticMap2!(Instantiate, myTypes, mySizes);

pragma(msg, result);

void main() {
}

Ali

On Monday, 6 February 2023 at 09:17:07 UTC, Ali Çehreli wrote:
> I adapted staticMap's implementation to two sets of arguments:

Thanks Ali, that's perfect. I thought of splitting the args in half a few hours later but hadn't got around to trying it.

On 2/8/23 12:04, John Chapman wrote:

> rather than write it manually for each N?

import std.meta : AliasSeq;

template pickArgs(size_t totalElements,
                  size_t argsPerElement,
                  size_t whichElement,
                  args...) {
    alias pickArgs = AliasSeq!();
    static foreach (a; 0 .. argsPerElement) {
        pickArgs = AliasSeq!(pickArgs, args[whichElement + a * totalElements]);
    }
}

template staticMapN(size_t N, alias fun, args...)
{
    static assert(N != 0, "N must be non-zero.");
    static assert((args.length % N) == 0,
                  "Mismatched number of arguments");

    enum totalElements = args.length / N;

    alias staticMapN = AliasSeq!();
    static foreach (e; 0 .. totalElements) {
        staticMapN = AliasSeq!(staticMapN,
                               fun!(pickArgs!(totalElements, N, e, args)));
    }
}

// An example struct with some template parameters
struct S(T, size_t length, size_t foo, size_t bar) {
}

// An example template that creates instantiations of the S template
template Instantiate(T, size_t length, size_t foo, size_t bar) {
    alias Instantiate = S!(T, length, foo, bar);
}

// Compile-time argument sets for three instantiations of the S template
alias myTypes = AliasSeq!(int, double, long);
alias mySizes = AliasSeq!(1, 2, 3);
alias myFoos = AliasSeq!(42, 43, 44);
alias myBars = AliasSeq!(100, 200, 300);

// A test with those 4 sets of template arguments
alias result = staticMapN!(4, Instantiate, myTypes, mySizes, myFoos, myBars);
pragma(msg, result);

void main() {
}

I could not figure out eliminating the hard-coded 4. Can we introspect the parameter list of a template like 'fun' in the example? If we could, then we could get 4 that way.

Ali

On 2/9/23 12:45, John Chapman wrote:
> On Thursday, 9 February 2023 at 19:17:55 UTC, Ali Çehreli wrote:
>> I could not figure out eliminating the hard-coded 4. Can we introspect
>> the parameter list of a template like 'fun' in the example? If we
>> could, then we could get 4 that way.
>
> Thank you for this. I don't mind hard-coding the N argument.
> TemplateArgsOf needs an instantiated template but maybe ```enum N =
> count(fun.stringof, ',') + 1``` is good enough.

Hopefully but very fragile:

template t(int[] T = [ 1, 2 ]) {}

void main() {
    import std.algorithm : count;
    enum N = count(t.stringof, ',') + 1;
    static assert(N == 1); // FAILS
}

Same thing with any other thing with comma in it e.g.

template t(T = anotherTemplate!(1, 2)) {}

Ali