I'm guessing that containers will help with this, but I'm not sure how.
Say I have an int[][] of unknown length and I want to get the setIntersection
of all int[]s. The only way I can see to do that is to intersect the first two
elements and iterate over them storing into an int[] which can be used in an
intersection with the next element...
I realize that a Range is meant to be view of a container, but it seems to me
that containing a Range can be just as useful. How might containers improve
this situation?
-----------------------------------
import std.algorithm;
void main() {
auto lists = [[1,2,3,4,5],
[2,4,6,8,10],
[1,1,2,3,5]];
//assert(setIntersection(lists) == [2]);
auto result = setIntersection(lists[0], lists[1]);
foreach(range; lists)
result = setIntersection(result, range);
}
-------------------------------
.\setint.d(13): Error: cannot implicitly convert expression (setIntersection(res
ult,range)) of type SetIntersection!(less,SetIntersection!(less,int[],int[]),int
[]) to SetIntersection!(less,int[],int[])

I'm guessing that containers will help with this, but I'm not sure how.
Say I have an int[][] of unknown length and I want to get the
setIntersection of all int[]s. The only way I can see to do that is to
intersect the first two elements and iterate over them storing into an int[]
which can be used in an intersection with the next element...
I realize that a Range is meant to be view of a container, but it seems to
me that containing a Range can be just as useful. How might containers
improve this situation?
I don't know if containers can help, but ranges of ranges do exist, with no

problem.
auto lists = [[0,1,2,3], [4,5,6], [7], [], [8]];
auto mapped = map!((int[] arr) { return map!"a*a"(arr))(lists); // The
delegate literal takes an array and returns an array.
Here, the topology is preserved and you get back a range of ranges, with the
same lengths and rank
[[0,1,4,9], [16,25,36], [49], [], [64]]

SetIntersection is lazy: it works for ranges of unknown length, even
infinite ones, and calculates only the intersection elements that you ask
for. This means in D storing it in a struct, which has a type encoding the
entire operation.
So the type of result is indeed SetIntersection!(less, int[],int[]), whereas
a new application will wrap another layer around it. You have a matriochka
of types, which cannot be converted.
But you can 'collapse' the result using array() to get back an array, if
you're certain your result is finite in length. Let's call that fuse:
T[] fuse(T)(T[] a1, T[] a2) {
return array(setIntersection(a1,a2));
}
What you're doing in your case is accumulating a result, so it's a
fold/reduce operation:
auto intersect = reduce ! fuse (lists);
Which works...
As setIntersection takes a variable number of ranges, it'd be interesting to
have a way to 'crack open' a range of ranges and transform it into a tuple
of ranges. The problem is, a tuple has a compile-time length. If lists was
an int[][3], you could make a template transforming it into a
TypeTuple!(int[],int[],int[]) that you can pass to setIntersection, opening
it with .expand.
But that's not possible in general for a dynamic array of dynamic arrays, as
its number of elements is only known at runtime. Maybe that's what you where
asking?
I did a recursive map a few weeks ago, wich maps a function on the innermost
elements of a range of ranges of ... of ranges.
I was looking for operations that preserve the topology (mapping on a tree
and returning a tree of the same shape).
Philippe