On Sun, Nov 8, 2009 at 21:14, dsimcha wrote:

> function like in python. Which does something like
> zip(iota(1,bar.length),bar).

> I think the index variant would better be done as an enumerate()
Enumerate is a great idea. It's probably much better than requiring every range
struct to mix something in to enable this behavior. Thanks.

FWIW, I coded enumerate and such for D2, and will post them on dsource as soon as I can get my hands on svn. In a few days at most, I hope.

Personally, I then use a 'tuplify' template which takes a standard function and transforms it into a tuple-accepting one:
so if I have:

int foo(int a, double b, string c) {...}
tuplify!foo is :
int tfoo(Tuple!(int, double, string) t) { /* extracts a,b & c from t, and returns foo(a,b,c) */ }

so, as I can't unpack the tuple:

foreach(a,b,c ; zip(range1, range2, range3) {
/* do something with foo on (a,b,c) */
}

I tuplify foo and do:

foreach (tup; zip(range1, range2, range3) {
/* do something with tuplify!foo(tup) */
}
There is no real limit on the number of ranges that can be acted upon in parallel that way, though I admit the syntax is a bit cumbersome.

I also use unzip!index( someZip) to get back the original range from inside zip.

I guess the same thing could be applied to unpack(). Instead of making the range
implementer mixin something to enable this (he/she will probably forget and it
could lead to ambiguities), do it on the caller end.

Makes me wonder why noone thought of this until now, or maybe someone did and I
forgot. How's:

foreach(fooElem, barElem; unpack(zip(foo, bar))) {}, or:

foreach(i, elem; enumerate(chain(foo, bar))) {} ?