Logic const with lazy const

[bearophile via Digitalmars-d]

I guess other persons have already suggested something like this. 
Here there is a "lazy immutable" instance member x, that can be 
only in two states: not initialized, and initialized with an 
immutable value.

The type system ensures x is never read before it's written, and 
that it's written no more than once (and to do this I presume it 
needs flow analysis).

The point of this idea is to make the bar() method const despite 
the x instance attribute is computed only if it's needed. This is 
useful is spam() requires significant computations, but x is not 
always needed. So it allows bar() to be "logically const" in a 
verified correct way.


int spam() pure nothrow @safe @nogc {
    // Lot of computations here.
    return 0;
}

struct Foo {
    private lazy immutable int x;
    static assert (this.x.sizeof == 8);

    int bar() const pure nothrow @safe @nogc {
        if (this.x.isNull) {
            this.x = spam();
        }
        return this.x;
    }
}

void main() {}


Bye,
bearophile