I suggest to add anything that is not yet there and applicable to ranges listed
here up to and excluding 'special lists':

http://www.haskell.org/ghc/docs/latest/html/libraries/base/Data-List.html

A simpler alternative idea is to just extend zip() to optionally accept a function/constructor (it's also good for map() to accept a struct name):

import std.range;
void main() {
    auto r1 = zip!q{a + b}([1,2,3], [10,20,30]);
    static struct Vec { int x, y; }
    auto r2 = zip!Vec([1,2,3], [10,20,30]);
}

(In reply to comment #2)
> A simpler alternative idea is to just extend zip() to optionally accept a
> function/constructor (it's also good for map() to accept a struct name):
> 
> import std.range;
> void main() {
>     auto r1 = zip!q{a + b}([1,2,3], [10,20,30]);
>     static struct Vec { int x, y; }
>     auto r2 = zip!Vec([1,2,3], [10,20,30]);
> }

I prefer this. 'zip' would become 'zipWith' with a default template argument of
'tuple'. (map already accepts a struct with an appropriate constructor as that
fits the 'callable' definition.)

(In reply to comment #3)

> (map already accepts a struct with an appropriate constructor as that
> fits the 'callable' definition.)

Right. But this shows a different limit. I think code like this is accepted in Clojure:


import std.algorithm: map;
void main() {
    auto keys = [1, 2, 1, 1, 1];
    auto a = [0, 10, 20];
    auto r1 = map!(k => a[k])(keys); // OK
    auto r2 = map!a(keys);           // Error
    auto aa = [1: 10, 2: 20];
    auto r3 = map!(k => aa[k])(keys); // OK
    auto r4 = map!aa(keys);           // Error
}

Another example:

import std.stdio: writeln;
import std.algorithm: map, filter;
void main() {
    int[] data = [0, 1, 2, 3];
    bool[] mask = [true, false, true, false];
    int[int] conv = [0:10, 1:20, 2:30, 3:40];
    auto r1 = data
              .filter!(i => mask[i])()
              .map!(i => conv[i])();
    writeln(r1); // Prints: [10, 30]
}


This is nicer:

import std.stdio: writeln;
import std.algorithm: map, filter;
void main() {
    int[] data = [0, 1, 2, 3];
    bool[] mask = [true, false, true, false];
    int[int] conv = [0:10, 1:20, 2:30, 3:40];
    auto r2 = data.filter!mask().map!conv();
    writeln(r2);
}

Two more examples:


import std.algorithm: filter;
import std.functional: not;
void main() {
    bool[] bad = [true, true, false, false, true, false];
    auto items = [0, 1, 2, 3, 4, 5];
    auto r1 = items.filter!bad();
    auto r2 = items.filter!(not!bad)();
}


...\dmd2\src\phobos\std\algorithm.d(1226): Error: function expected before (), not bad of type bool[]
...\dmd2\src\phobos\std\algorithm.d(1248): Error: function expected before (), not bad of type bool[]
...\dmd2\src\phobos\std\algorithm.d(1214): Error: template instance test.main.FilterResult!(bad, int[]) error instantiating
test.d(6):        instantiated from here: filter!(int[])
test.d(6): Error: template instance test.main.filter!(bad).filter!(int[]) error instantiating
...\dmd2\src\phobos\std\algorithm.d(1226): Error: template test.main.not!(bad).not does not match any function template declaration. Candidates are:
...\dmd2\src\phobos\std\functional.d(184):        test.main.not!(bad).not(T...)(T args) if (is(typeof(!unaryFun!(pred)(args))) || is(typeof(!binaryFun!(pred)(args))))
...\dmd2\src\phobos\std\algorithm.d(1226): Error: template test.main.not!(bad).not(T...)(T args) if (is(typeof(!unaryFun!(pred)(args))) || is(typeof(!binaryFun!(pred)(args)))) cannot deduce template function from argument types !()(int)
...\dmd2\src\phobos\std\algorithm.d(1248): Error: template test.main.not!(bad).not does not match any function template declaration. Candidates are:
...\dmd2\src\phobos\std\functional.d(184):        test.main.not!(bad).not(T...)(T args) if (is(typeof(!unaryFun!(pred)(args))) || is(typeof(!binaryFun!(pred)(args))))
...\dmd2\src\phobos\std\algorithm.d(1248): Error: template test.main.not!(bad).not(T...)(T args) if (is(typeof(!unaryFun!(pred)(args))) || is(typeof(!binaryFun!(pred)(args)))) cannot deduce template function from argument types !()(int)
...\dmd2\src\phobos\std\algorithm.d(1214): Error: template instance std.algorithm.FilterResult!(not, int[]) error instantiating
test.d(7):        instantiated from here: filter!(int[])
test.d(7): Error: template instance std.algorithm.filter!(not).filter!(int[]) error instantiating

- - - - - - - - - - - - - - - -

import std.algorithm: filter;
struct IsOdd {
    static bool opCall(in int n) {
        return n % 2 == 1;
    }
}
void main() {
    auto items = [0, 1, 2, 3, 4, 5, 6, 7, 8];
    auto r1 = items.filter!(i => IsOdd(i))(); // OK
    auto r2 = items.filter!IsOdd(); // Error.
}


test.d(10): Error: template instance filter!(IsOdd) filter!(IsOdd) does not match template declaration filter(alias pred) if (is(typeof(unaryFun!(pred))))

THIS ISSUE HAS BEEN MOVED TO GITHUB

https://github.com/dlang/phobos/issues/9939

DO NOT COMMENT HERE ANYMORE, NOBODY WILL SEE IT, THIS ISSUE HAS BEEN MOVED TO GITHUB