Passing template alias to a function

[monkyyy]

On Wednesday, 6 August 2025 at 22:41:28 UTC, Andrey Zherikov 
wrote:
> This is simplified code that illustrates the issue I've faced:
> ```d
> struct A(T) {}
>
> alias B(T) = A!T;
>
> void f(T)(B!T b) {}
>
> f(B!string.init);
> // Error: template `f` is not callable using argument types 
> `!()(A!string)`
> //f(B!string.init);
> // ^
> //       Candidate is: `f(T)(B!T b)`
> //void f(T)(B!T b) {}
> //     ^
> ```
>
> I know that I can do `alias B = A` in this specific example, 
> but in the actual code, I'm trying to do `alias B(T) = A!(H!T)` 
> which leads to the same error:
> ```d
> struct A(T) {}
> struct H(T) {}
>
> alias B(T) = A!(H!T);
>
> void f(T)(B!T b) {}
>
> f(B!string.init);
> // Error: template `f` is not callable using argument types 
> `!()(A!(H!string))`
> //f(B!string.init);
> // ^
> //        Candidate is: `f(T)(B!T b)`
> //void f(T)(B!T b) {}
> //     ^
> ```

```d
struct A(T) {}
struct H(T) {}

alias B(T) = A!(H!T);

void f(T)(A!(H!T) b) {}
void g(T)(A!T b) {}
void h(B_)(B_ b)if(is(B_==A!(H!T),T)){}
unittest{
     f(B!string.init);
     g(B!int.init);
     h(B!bool.init);
}
```

I dont think you should actually try to pull patterns out of `h`, 
and just go with a `void i(T...)(T args)` if you have something 
complex to match but without a usecase, who knows

---

I think your mistaken about aliased types existing, Idk what the 
spec says but these seem awfully "eager"
```d
alias C(T,int i)=A!(H!T);
void j(T)(T b){
     pragma(msg,typeof(b).stringof);
}
unittest{
     j(C!(float,10).init);//A!(H!float)
     pragma(msg,typeof(C!(float,10).init).stringof);//A!(H!float)
}
```

As far as I know there is no way to recover the 'i' so does 
`C!(float,10)` even exist?

```d
alias foo=int;
unittest{
     pragma(msg,__traits(identifier,foo));//Error: argument `int` 
has no identifier
}
```