Transforming Array!(Array!T) into a range of ranges

3
votes
import std.container: Array;
import std.algorithm: map;
import std.range: transposed;
import std.stdio: writeln;
Array!(Array!int) a;
a.insertBack(Array!int(1,2,3));
a.insertBack(Array!int(4,5,6));
writeln(a[].map!((ref a) => a[]).transposed);

Error: template std.range.transposed cannot deduce function from argument types !()(MapResult!(__lambda1, RangeT!(Array!(Array!int))))

I am not quite sure what happens here, isn't this supposed to be a range of ranges? Why can't D deduce the type?

How would I transform an Array!(Array!T) to a range of ranges?

1
d

1 Answers

2
votes

The template constraint of transposed is this:

if (isForwardRange!RangeOfRanges &&
    isInputRange!(ElementType!RangeOfRanges) &&
    hasAssignableElements!RangeOfRanges)

We can use pragma(msg) to figure out which of those constraints is failing:

auto m = a[].map!((ref a) => a[]);
pragma(msg, isForwardRange!(typeof(m)));
pragma(msg, isInputRange!(ElementType!(typeof(m))));
pragma(msg, hasAssignableElements!(typeof(m)));

For me, it prints:

true
true
false

Which means that the range does not have assignable elements.

This is likely because Array's opSlice doesn't return an lvalue (in which case the map function could also return an lvalue), and there is no way to "unmap" the a[] slice into the array to support assignment to a through the Map.

As a workaround, you can use an Array of slices:

Array!(int[]) a;

a.insertBack([1,2,3]);
a.insertBack([4,5,6]);
writeln(a[].transposed);