Non-consistent implicit function template specializations

[Steven Schveighoffer]

On 8/17/21 10:20 AM, Rekel wrote:
> As my post was not the actual cause of my issue (my apology for the 
> mistake), I think I have found the actual reason I'm currently having 
> problems.
> This seems to be related to a (seeming, I might be wrong) inability to 
> specialize over both 1d and 2d arrays separately. (If constraining the 
> length to values.)
> 
> This brings me to 2 questions.
> 1. How does one specialize a template for both 1d and 2d arrays at the 
> same time?
> 2. Are there any plans to rework templates? like:
> - Making `template TFoo(T : T[])` illegal. This makes little sense to me 
> however I look at it, and as several people have advised against it it's 
> confusing it's in the docs. (21.4.1)
> - Changing the way priorities are set using specializations in general, 
> to make them less pitfall-y.
> - Allow for 2+d length specification. At the moment `T[][L]` works while 
> `T[L][L]` does not seem to.

You should try out things individually to see if they at least work.

> 
> ```d
> void foo(T)(T a){...}
> 
> void foo(T:U[L], uint L)(T a){...}

This is an invalid specification, what is U? Did you mean:

void foo(T: U[L], U, uint L)(T a) {...}

> void foo(T:U[L][L], uint L)(T a){...} // Never matched

Apart from another missing U, this is only a SQUARE 2d-array (both 
dimensions the same), your example below only calls with a 1x2 array.

> void foo(T:U[L], U:V[L], V uint L)(T a){...} // Never matched 
> (alternatively)

I don't think you need this, and I had to comment it out, or the 
compiler wouldn't build.

> 
> // Should work with
> void main(string[] args) {
>      foo([[1],[2]]);
>      foo([1,2]);
>      foo(1);
> }
> ```

All these are calling with array literals, which default to dynamic 
arrays, not static arrays.

-Steve