Nested map calls

[jmh530]

I have one function that applies map and then another function calls that function and adds another map to it. I get an error about nesting pipe calls or something. If I manually use pipe or combine the functions, then there is no error.

auto foo(T)(T x)
{
    import mir.ndslice.topology : map;

    return x.map!(a => a + 1);
}

auto bar(T)(T x)
{
    import mir.ndslice.topology : map;

    return x.foo.map!(a => a + 2);
}

void main()
{
    import mir.ndslice.topology : iota, map;
    import mir.functional : pipe;
    import std.stdio : writeln;

    auto data = iota(5);
    auto result = iota([5], 3);

    auto x = data.map!(a => a + 1).map!(a => a + 2); //piping them normally works correctly
    assert(x == result);
    
    auto y = data.bar; //error here
    //assert(y == result);
    
    auto z = data.pipe!(foo, a => a + 2); //this works too
    assert(z == result);
}

Error (note: using 0.7.0-alpha8):

C:\ProgrammingFiles\DFiles\testing\testing_mir_algorithm>dub run
Performing "debug" build using dmd for x86.
mir-algorithm 0.7.0: target for configuration "library" is up to date.
testing_mir_algorithm 0.0.1: building configuration "application"...
..\..\dubFolder\mir-algorithm-0.7.0-alpha8\source\mir\ndslice\iterator.d(621,71)
: Error: template instance pipe!(__lambda2, __lambda2) pipe!(__lambda2, __lambda
2) is nested in both foo and bar
..\..\dubFolder\mir-algorithm-0.7.0-alpha8\source\mir\ndslice\iterator.d(633,24)
: Error: template instance app.bar!(Slice!(cast(SliceKind)2, [1u], IotaIterator!
int)).bar.__map!(__lambda2) error instantiating
..\..\dubFolder\mir-algorithm-0.7.0-alpha8\source\mir\ndslice\topology.d(2262,52
):        instantiated from here: mapIterator!(__lambda2, MapIterator!(IotaItera
tor!int, __lambda2))
source\app.d(12,17):        instantiated from here: map!(cast(SliceKind)2, [1u],
 MapIterator!(IotaIterator!int, __lambda2))
source\app.d(27,18):        instantiated from here: bar!(Slice!(cast(SliceKind)2
, [1u], IotaIterator!int))
dmd failed with exit code 1.

[jmh530]

Note: That should be a unittest block instead of void main().

[9il]

@jmh530 Please report a complier bug (with the note that it is Mir's map).

[jmh530]

@ilya It might be helpful if I can narrow down what the compiler bug is. For instance, this is not an issue with std.algorithm's map.

import std.algorithm : map;

auto foo(T)(T x)
{
    return x.map!(a => a + 1);
}

auto bar(T)(T x)
{
    return x.foo.map!(a => a + 2);
}

void main()
{
    import std.range : iota;
    import std.algorithm.comparison : equal;

    auto data = iota(0, 5);
    auto result = iota(3, 8);

    auto x = data.map!(a => a + 1).map!(a => a + 2);
    assert(equal(x, result));
    
    auto y = data.bar;
    assert(equal(y, result));
}

[n8sh]

I've tried to narrow it down a bit. This runs without importing any of mir:

import std.traits;

struct Slice(Iterator)
{
    public size_t _length;

    public Iterator _iterator;

    size_t length() @safe @property const
    {
        return _length;
    }

    bool empty() @safe @property const
    {
        return length == 0;
    }

    auto ref front() @trusted @property
    {
        assert(!empty);
        return *_iterator;
    }

    void popFront() @trusted
    {
        assert(!empty, __FUNCTION__ ~ ": length should be greater than 0!");
        --_length;
        ++_iterator;
    }

    bool opEquals(T)(T[] arr) @trusted const
    {
        auto slice = cast(Slice!Iterator)this;
        if (slice.length != arr.length)
            return false;
        if (arr.length) do
        {
            if (slice.front != arr[0])
                return false;
            slice.popFront;
            arr = arr[1 .. $];
        }
        while (arr.length);
        return true;
    }
}

auto sliced(T)(T[] array) @safe
{
    auto ptr = &array[0];
    return Slice!(typeof(ptr))(array.length, ptr);
}

private template _pipe(size_t n)
{
    static if (n)
    {
        enum i = n - 1;
        enum _pipe = "f[" ~ i.stringof ~ "](" ~ ._pipe!i ~ ")";
    }
    else
        enum _pipe = "args";
}

private template _unpipe(alias fun)
{
    static if (__traits(compiles, TemplateOf!fun))
    static if (__traits(isSame, TemplateOf!fun, .pipe))
        alias _unpipe = TemplateArgsOf!fun;
    else
        alias _unpipe = fun;
    else
        alias _unpipe = fun;
}

template pipe(fun...)
{
    alias f = staticMap!(_unpipe, fun);
    static assert (fun.length != 1 && f.length == fun.length, "Other cases do not occur in this example!");
    auto ref pipe(Args...)(auto ref Args args)
    {
        return mixin (_pipe!(fun.length));
    }
}

auto MapIterator__map(Iterator, alias fun0, alias fun)(ref MapIterator!(Iterator, fun0) it)
{
    return MapIterator!(Iterator, fun)(it._iterator);
}

struct MapIterator(Iterator, alias fun)
{
    Iterator _iterator;

    static alias __map(alias fun1) = MapIterator__map!(Iterator, fun, pipe!(fun, fun1));

    auto ref opUnary(string op : "*")()
    {
        return fun(*_iterator);
    }

    auto ref opIndex()(ptrdiff_t index)
    {
        return fun(_iterator[index]);
    }

    void opUnary(string op)()
        if (op == "--" || op == "++")
    {
        mixin(op ~ "_iterator;");
    }
}

auto mapIterator(alias fun, Iterator)(Iterator iterator)
{
    static if (__traits(hasMember, Iterator, "__map"))
        return Iterator.__map!fun(iterator);
    else
       return MapIterator!(Iterator, fun)(iterator);
}

template map(alias fun)
{
    auto map(Iterator)
        (Slice!(Iterator) slice)
    {
        auto iterator = slice._iterator.mapIterator!fun;
        return Slice!(typeof(iterator))(slice.length, iterator);
    }
}

auto foo(T)(T x)
{
    return x.map!(a => a + 1);
}

auto bar(T)(T x)
{
    return x.foo.map!(a => a + 2);
}

void main()
{
    import std.stdio : writeln;

    auto data = [0,1,2,3,4].sliced;
    immutable result = [3,4,5,6,7];

    auto x = data.map!(a => a + 1).map!(a => a + 2); //piping them normally works correctly
    assert(x == result);
    
    //auto y = data.bar; //error here
    //assert(y == result);
    
//This doesn't work due to all the stuff I've removed:
    //auto z = data.pipe!(foo, a => a + 2); //in the non-stripped version this works too
    //assert(z == result);
}

[n8sh]

@jmh530 I've identified exactly where the problem is. In the above narrow example if you comment out the definition of __map in MapIterator then then auto y = data.bar works.

//static alias __map(alias fun1) = MapIterator__map!(Iterator, fun, pipe!(fun, fun1));

I changed this after observing that the phobos version of map doesn't use phobos pipe to coalesce nested/chained map calls. I think coalescing map calls is great and I would like to figure out why what should be equivalent notation results in non-compiling code.

EDIT:
Thinking about it a bit more, it's not obvious to me that the other way would be any slower when optimizations are enabled. Do we know that MapIterator!(int*, pipe!(__lambda1, __lambda2)) is any more efficient than MapIterator!(MapIterator!(int*, __lambda1), __lambda2)?

[jmh530]

@n8sh Thanks for your help with this!