Re: "fold": a replacement for "reduce"

[bearophile]

monarch_dodra:

I'm taking this naming-changing event as an opportunity to 
"cleanup" reduce too.

This is possibly silly question, or perhaps fit just for D.learn. 
But I think it's sufficiently in topic in this thread.

You have a function foo1 like this:


import std.range, std.algorithm, std.array;

uint[] foo1(uint[][] X) {
    return X.reduce!((i, j) => zip(i, j)
                               .map!(kw => kw[0] | kw[1])
                               .array);
}

void main() {
    import std.stdio;
    uint[][] m1 = [[10, 20], [30, 40]];
    foo1(m1).writeln;
}


foo1 doesn't need to change its input so I'd like to use the 
signature:

int[] foo1(in int[][] X) {

But that can't work because reduce returns a const.

And you can't do this because it returns a wrong result:

uint[] foo2(in uint[][] X) {
    return reduce!((i, j) => zip(i, j)
                             .map!(kw => kw[0] | kw[1])
                             .array)
                  ((uint[]).init, X);
}



This seems OK, but can fold offer a better solution?:

uint[] foo3(in uint[][] X) {
    return reduce!((i, j) => zip(i, j)
                             .map!(kw => kw[0] | kw[1])
                             .array)
                  (X[0].dup, X[1 .. $]);
}

Bye,
bearophile