Cannot always deduce template arguments when using implicitly cast array literals

[Rekel]

After simplifying a part of my code I found the following code 
cannot deduce the template arguments, but I have no clue why.

```d
void foo(L : T[L1][L2], uint L1, uint L2, T, R:
		T[L1])(const L left, const R right) {
	// Function
}

void bar(uint L)(float[L] l) {
	// Function
}

void main(string[] args) {
	foo2([1.0f, 2, 3, 4, 5, 6, 7, 8]); // implicitly cast to 
float[8], works
	float[4][1] l = [[1, 2, 3, 4]];
	foo!(typeof(l), 4, 1, float, float[4])(l, [1.0f, 2, 3, 4]); // 
also works
	foo(l, [1.0f, 2, 3, 4]); // cannot deduce function from argument 
types (?)
}
```

As one can see, implicitly casting array literals in templates 
works fine in the case of bar, as does explicit use of templates 
in the case of foo, but for some reason foo does not manage to 
deduce its arguments like bar does.
The type of l is well known, and given the template, the type of 
R should thus be known as well. T[L1] should be deduced to 
float[4].
Did I make a mistake in the argument list? I know things like the 
order are sometimes issues, but that seems fine to me here. 
Seeing as bar functions fine (as does foo when R and right are 
removed) I'm at a loss.

Thanks you in advance!