Hi,
I was reading the source of std.algorithm cache and saw some code
that didn't make sense to me with a comment indexing the [bug
report](https://issues.dlang.org/show_bug.cgi?id=15891). Could
anyone help to understand if this code is really necessary
(meaning I have some misconception) or is it a work around a
compiler bug. Here is the code simplified down as much as I could:
```d
import std.range.primitives;
import std.traits;
struct _Cache(R)
{
private
{
alias UE = Unqual!(ElementType!R);
R source;
UE caches;
}
this(R range)
{
source = range;
if (!range.empty)
{
caches = source.front;
}/* else { //Uncomment "else" to fix broken version
(see below)
caches = UE.init;
}*/
}
}
struct _ConstructorlessCache(R) {
private
{
alias UE = Unqual!(ElementType!R);
R source;
UE caches;
}
}
auto constructorlessCache(Range)(Range range) {
auto ret = _ConstructorlessCache!Range(range);
if (!range.empty)
{
ret.caches = range.front;
}
return ret;
}
auto cache(Range)(Range range) {
return _Cache!(Range)(range);
}
auto map(alias fun, Range)(Range range) {
return MapResult!(fun,Range)(range);
}
struct MapResult(alias fun, Range)
{
alias R = Unqual!Range;
R _input;
bool empty() { return _input.empty; }
auto ref front() { return fun(_input.front); }
}
void main() {
/* Won't compile unless part near top is uncommented. Gives:
onlineapp.d(21): Error: one path skips field `caches`
onlineapp.d(75): Error: template instance
`onlineapp.cache!(MapResult!(__lambda1, int[]))` error
instantiating
*/
//[1].map!(x=>[x].map!(y=>y)).cache;
//What seems to be essentially the same code compiles fine
[1].map!(x=>[x].map!(y=>y)).constructorlessCache;
}
```
