Using map result type

[AA]

On Sunday, 8 December 2019 at 01:43:43 UTC, mipri wrote:
> On Sunday, 8 December 2019 at 01:10:21 UTC, AA wrote:
>> [...]
>
> In general this is what you want to do with any kind of range
> code, because you're not working with definite types, but with
> types that have certain properties. And an advantage of this is
> that you can decide to do more or less efficient things at
> compile time based on additional properties of the types you're
> working with. Just open up phobos and look for 'static if':
>
> https://github.com/dlang/phobos/blob/master/std/algorithm/searching.d#L3858
>
> So if you you give minPos an array, it'll just foreach() over
> the array and return a slice. In which case minPos is exactly
> as efficient as the code you would've written by hand instead
> of using minPos, because it expands to that same code.
>
> And if you give minPos something else, it'll still work.
>
>> [...]
>
>> [...]
>
> Not really. Even if you try to use typeof() to get the
> (internal) type that std.alogorithm.map returns, you'll run
> into errors like
>
> Error: function x253.mapAccepter(MapResult!(__lambda5, int[]) 
> r) is not callable using argument types (MapResult!(__lambda1, 
> int[]))
>
> when you try to use it.
>
>> [...]
>
> Certainly. Static reflection's what this kind of generic code
> is all about. See all the constraints in the std.algorithm pages
> in the library documentation?  Just look at this one, randomly
> picked:
> https://dlang.org/phobos/std_algorithm_searching.html#.endsWith
>
>   if (isBidirectionalRange!Range
>       && (Needles.length > 1)
>       && is(typeof(.endsWith!pred(doesThisEnd, 
> withOneOfThese[0])) : bool)
>       && is(typeof(.endsWith!pred(doesThisEnd, 
> withOneOfThese[1..$])) : uint));
>
> So for your code:
>
>   void mapAccepter(Range)(Range r)
>       if (is(ElementType!Range == bool))
>   {
>       import std.array : array;
>       import std.stdio : writeln;
>
>       auto collected = r.array;
>       writeln(collected);
>   }
>
> Or if you do this often, maybe something like this would do:
>
>   enum RangeOfBools(T) = is(ElementType!T == bool) && 
> isInputRange!T;
>
>   void mapAccepter(Range)(Range r) if (RangeOfBools!Range)
>   {
>       import std.array : array;
>       import std.stdio : writeln;
>
>       auto collected = r.array;
>       writeln(collected);
>   }

Thanks for the detailed reply. So maybe it is just my perspective 
coming from other languages that I was expecting a class i.e. 
having some interface based way of dealing with the return type. 
But I guess isInputRange checks for structural equality rather 
than class and doesn't encode that into any interfaces in std 
library normally?

Would the second solution of declaring a template constraint like 
that be considering strange/out of place in D? e.g. do people 
normally try and declare the template constraints on a function 
or just rely on compile time failure from to instantiate template.