Lazy caching map()?

[aliak]

On Friday, 9 March 2018 at 19:41:46 UTC, H. S. Teoh wrote:
> Today I found myself needing a lazy, caching version of map() 
> on an array.  More precisely, given an array `T[] src` of 
> source data and a function func(T) that's pretty expensive to 
> compute, return an object `result` such that:
>
> - result[i] == func(src[i]), for 0 ≤ i < src.length.
>
> - If result[j] is never actually used, func(src[j]) is never 
> invoked
>   (lazy).
>
> - If result[j] is referenced multiple times, a cached value is 
> returned
>   after the first time, i.e., the result of func(src[j]) is 
> cached, and
>   func(src[j]) is never invoked more than once.
>
> I couldn't figure out how to build this using Phobos 
> primitives, so I wrote my own implementation of it.  Pretty 
> simple, really, it's just a wrapper struct that lazily 
> initializes an array of Nullable!T and lazily populates it with 
> func(j) when opIndex(j) is invoked, and just returns the cached 
> value if opIndex(j) has been invoked before.
>
> Can this be done using current Phobos primitives?
>
>
> T

Unless I'm misunderstanding your requirements, are you looking 
for std.functionl.memoize?

auto fun(int a) {
     writeln("here");
     return a + 1;
}

void main() {
     auto a = [1, 2, 3];
     auto b = a.map!(memoize!fun);

     writeln(b[1]);
     writeln(b[1]);
     writeln(b[1]);
}

will print "here" just once.