Checking a (base) type and accepting any specialization?

[mitgedanken]

On Sunday, 8 June 2025 at 14:29:27 UTC, mitgedanken wrote:
> I have following situation:
>
> I have a struct ``Routine`` (base type) and its specializations 
> ``!n``.
>
> ```d
> struct Routine (uint argscount = 1) {
>     string name;
>     void delegate(inout Arguments!argscount) return call;
> }
>
> const auto ROUTINES = [
>     Routine!3(":input", toDelegate(&routine_input)),
>     Routine!2(":print", toDelegate(&routine_print)),
> ];
> ```
>
> I understand why the given types are not compatible.
> But not how I can store any base type regardless its 
> specialization.

I thought the code was self-explanatory. But I was wrong about 
that. Whereby you are going in the right direction.

I have a ``struct`` "Argument".
```d
struct Argument (alias data) {
     alias TData = typeof(Data);
     TData data;
}
```
```d
struct Arguments (uint argcount, alias Data) {
     Argument!Data[argcount] args;
}
// Is this struct needed? An alternative please.
```

And a ``struct`` "Routine".
```d
struct Routine(uint argcount, alias Data, alias ReturnValue) {
     alias TRet = typeof(ReturnValue);
     alias TArg = Argument!(Data);
     alias Args = Argument!Data[argcount];

     static if (argCount > 0) {
         TRet delegate(TArg Args) call;
     }
     else {
         TRet delegate() call;
     }
}
```

I want to specify through these ``struct``s that a routine ...
A. returns the type ``TRet``
B. how many arguments (and their type*) it needs

**Background**
I write a simple programming language. For this I define routines 
that can be called by the user. The routines are therefore 
predefined. But they should be read by a ``const``. Of course I 
could also build it into the parser/lexer, like everything else, 
but that is not my problem.

Does this help?