On 9/20/16 12:17 AM, crimaniak wrote:
Hi and thanks all!

On Tuesday, 20 September 2016 at 00:43:10 UTC, Jonathan M Davis wrote:

immutable string executablePath;

shared static this()
    import std.file : thisExePath();
    executablePath = thisExePath();

This code is good for my needs but I start to think about how to call
thisExePath only if it is really used and come to this solution:

import std.traits: ReturnType, Parameters;

string staticMemoize(alias T, Parms = Parameters!T)() pure
    struct Holder(alias T)
        static shared immutable ReturnType!T value;
        shared static this(){ value = T(Parms); }

    return Holder!T.value;

    import std.file : thisExePath;
    assert(staticMemoize!thisExePath == thisExePath);

Something like this. Need to refine about input parameters, but I hope,
idea is clear.
Unlike the function memoize from phobos staticMemoize really pure. And
unlike proposed solution with ordinary variable staticMemoize is lazy,
because no call - no instantiation.

Yes, but if your code does instantiate it, it is called, even if you don't ever call the function that calls it.

Note that if you don't import the module that contains the static ctor, it should be trimmed by the linker.

I would absolutely caution you from putting static this() inside any template. Unfortunately, due to the way D generates these static constructors, any module that uses staticMemoize, or *imports a module that uses it*, will be marked as having a static constructor, and will potentially create cycles.


Reply via email to