Trying to do alias template deduction myself.

[Salih Dincer]

On Monday, 3 April 2023 at 19:50:14 UTC, Salih Dincer wrote:
> ... very elegant ...

I like it better when program prints:

```d
> import std.stdio;
import std.meta;

struct Matrix(U, size_t M, size_t N)
{
     U[M * N] data;
}

alias P = AliasSeq!(byte, short, int);
alias X = AliasSeq!(3, 3, 4);
alias Y = AliasSeq!(1, 3, 2);

void main()
{
   alias Vec3(U) = Matrix!(U, 3, 3);
   alias T = float;

   Vec3!T cube;
   void singleMatrix(U)(in Vec3!U v)
   {
     typeid(aTypeOf!(v.data)).write(": ");
     v.data.writeln;
   }

   singleMatrix!T(cube); // ok
   assert(is(typeof(cube) == Vec3!T));

   // ...

   alias Vec3Var(U...) = staticMapTrio!(Matrix, U);
   alias S = AliasSeq!(P, X, Y);

   Vec3Var!S trio;
   void triMatrix(U...)(in Vec3Var!(U) vps)
   {
     foreach(ref v; vps)
     {
       typeid(aTypeOf!(v.data)).write(": ");
       v.data.writeln;
     }
   }

   triMatrix!S(trio); // ok
   assert(is(typeof(trio) == Vec3Var!S));
}

template staticMapTrio(alias fun, args...) {
   alias staticMapTrio = AliasSeq!();
   static foreach (i; 0..args.length / 3) {
     staticMapTrio = AliasSeq!(staticMapTrio,
       fun!(args[0..$/3][i],
            args[$/3..($/3) * 2][i],
            args[($/3) * 2..($/3) * 3][i]
       )
     );
   }
}

template aTypeOf(alias A) {
   alias Type(T : T[]) = T;
   alias aTypeOf = Type!(typeof(A));
}

/* PRINTS:
float: [nan, nan, nan, nan, nan, nan, nan, nan, nan]
byte: [0, 0, 0]
short: [0, 0, 0, 0, 0, 0, 0, 0, 0]
int: [0, 0, 0, 0, 0, 0, 0, 0]
*/
```

SDB at 79