Template mixins and selective imports

[jmh530 via Digitalmars-d-learn]

I am trying to create a vectorize function that mixes in a new 
version of function with the same name that applies the function 
(to an ndslice).

The code below compiles without error and has the behavior I 
would expect.

However, when I change the function import to a selective import 
(e.g. from import std.math; to import std.math : sin;), then I 
get errors implying that the overload is not actually created.

Ideally, I would like to get this working with any kind of import.

One thing I noticed is that the fullyQualifiedName of sin changes 
quite a bit depending on whether you use one or the other.

This may be related to either of the following:
https://issues.dlang.org/show_bug.cgi?id=16287
https://issues.dlang.org/show_bug.cgi?id=16023



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

import std.traits : isFunction;

private enum _vectorize(string f) = "
     import mir.ndslice.slice : SliceKind, Slice;

     auto " ~ f ~ "(SliceKind kind, size_t[] packs, Iterator)
                                            (Slice!(kind, packs, 
Iterator) slice)
     {
         import mir.ndslice.topology : map;
         return slice.map!(f);
     }
";

mixin template vectorize(alias f)
     if (isFunction!f)
{
     mixin(_vectorize!(__traits(identifier, f)));
}

unittest
{
     import std.stdio : writeln;
     import mir.ndslice.slice : sliced;
     import mir.ndslice.topology : map;
     import std.math; //import std.math : sin;

     auto x = [0.0, 1.0, 2.0, 3.0].sliced;

     auto y = x.map!(sin);
     writeln(y);

     mixin vectorize!(sin);
     auto z = sin(x);
     writeln(z);
}