[patch] Add map() and filter() to tango.core.Array

Small typo fix ;)

BTW, I kept the double template thing because it was there, but I don't understand really its purpose. Also, I noticed that using the double template the functions can't accept static arrays as arguments and not using the double template thing make it work. So, is there any good reason to do that?

Shouldn't these functions take an optional buffer as its last argument, like many of the other array functions in Tango do.

Doesn't look like the case for tango.core.Array (for example intersectionOf(), missingFrom(), unionOf()). I think just for the sake of consistency in the module and simplicity of implementation I wouldn't add an optional buffer to these functions either. If that option want to be added in the future, all functions in this module can be modified together to keep consistency.

I could only come up with this implementation of map() to allow the function to return a different type than it takes:

        typeof(Fun(ElemTypeOf!(Buf)))[] map( alias Fun, Buf )( Buf buf )
        {
            typeof(Fun(ElemTypeOf!(Buf)))[] r;
            r.length = buf.length;
            for( size_t pos = 0, len = buf.length; pos < len; ++pos )
            {
                r[pos] = Fun( buf[pos] );
            }
            return r;
        }   

The usage though it's pretty different from the other functions in tango.core.Array, as the delegate has to be passed as a template argument: map!(dg)(collection);

Also this lacks the "double template" that I don't really know what's good for.

Anyway, comments and suggestions are welcome.

The following seems to work:

template map(TOut, TIn)
{
 TOut[] map(TOut function(TIn) func, TIn[] array)
 {
    TOut[] arr;
    arr.length = array.length;
    foreach (i, a; array) arr[i] = func(a);
    return arr;
 }
}

auto dg = function(int i) { return [cast(char)('0' + i + 1)] };
Stdout.formatln("{}", map(dg, [1, 2, 3, 4])); // [2, 3, 4, 5]

I'm not sure whether we want the function before the array, but I'd generally say "map a function onto an array", so...

Anyway, I'll take care of this today. Yell at me if it isn't done when you wake up tomorrow.

I think a weakness of that implementation is that the input has to be an array, but in my version it could be anything with indexing support and the callable has to be a function (not even a delegate can be used with your version I think), and in my version it could be any callable object (which I think is more in sync with the other functions in the module).

Check out the implementation I committed. It addresses your concerns.

There are at least some functions in that module that assume arrays. They should be fixed eventually.

OK, looks good to me, but I would reorder the arguments of map() and reduce() to take the array argument first, as mostly all other functions in tango.core.Array do.

Thanks.