import std.algorithm;

​

struct Nullable(T) {

    private union U {

        T value = T.init;

    }

    private @property ref _payload() inout { return _u.value; }

    private U _u;

    private bool _hasValue;

​

    @property @trusted

    ref T value() {

        assert(_hasValue);

        return _payload;

    }

​

    @property @trusted

    void value(T val) {

        cleanup();

        _hasValue = true;

        _payload = val;

    }

​

    @property

    void value(typeof(null)) {

        cleanup();

        _hasValue = false;

    }

​

    @trusted

    private void cleanup() {

        if (!_hasValue) return;

        destroy(_payload);

        _hasValue = false;

    }

​

    this(T val) {

        value = val;

    }

​

    ~this() {

        cleanup();

    }

​

    this(typeof(null) val) {

        value = val;

    }

​

    void opAssign(T val) @trusted {

        auto copy = U(val);

        if (_hasValue)

            _payload = val;

        else

            moveEmplace(copy.value, _payload);

    }

​

    void opAssign(typeof(null) val) {

        value = val;

    }

}

​

struct S

{

    immutable int i;

    Object obj;

    invariant

    {

        assert(this.obj !is null);

    }

    @disable this();

    @safe

    this(Object obj)

    {

        this.obj = obj;

    }

    @safe void opAssign(S) { /* ... */ }

    @safe ~this() {}

}

​

@safe unittest {

    Nullable!S a; // Look ma, no assert!

    a = S(new Object);

}