Generic Property Implementation

[bauss via Digitalmars-d-learn]

Would there be a reason why this wouldn't be a good 
implementation?

If so what and how could it be improved?
Are there flaws in an implementation like this?

struct Property(T, bool readOnly = false)
{
    import std.traits : isScalarType, isArray, 
isAssociativeArray, isSomeString;

    private T _value;

    T __GET() { return _value; }

    static if (readOnly)
    {
        private
        {
            void __SET(T newValue) { _value = newValue; }

            void opAssign(T newValue)
            {
                __SET(newValue);
            }
        }
    }
    else
    {
        void __SET(T newValue) { _value = newValue; }

        void opAssign(T newValue)
        {
            __SET(newValue);
        }
    }

    bool opEquals(T other)
    {
        static if (isScalarType!T || isArray!T || 
isAssociativeArray!T)
        {
            return _value == other;
        }
        else
        {
            if (_value is other) return true;
            if (_value is null || other is null) return false;
            if (typeid(_value) == typeid(other)) return 
_value.opEquals(other);
            return _value.opEquals(other) && 
other.opEquals(_value);
        }
    }

    static if (!(isArray!T) && !(isAssociativeArray!T))
    {
        int opCmp(T other)
        {
            static if (isScalarType!T)
            {
                if (_value < other) return -1;
                if (_value > other) return 1;

                return 0;
            }
            else
            {
                return _value.opCmp(other);
            }
        }
    }

    string toString()
    {
        static if (isArray!T && isSomeString!T)
        {
            return _value;
        }
        else static if (__traits(hasMember, T, "toString"))
        {
            return _value.toString();
        }
        else
        {
            import std.conv : to;

            return to!string(_value);
        }
    }

    alias __GET this;
}

alias ReadOnlyProperty(T) = Property!(T, true);

---

This would allow something like this:

class Foo
{
    ReadOnlyProperty!int bar;

    Property!string baz;

    Property!int faz;

    Property!Bar bar2;
}

class Bar
{
    int boo;
}

Which can be used like:

    auto foo = new Foo;
    foo.baz = "Hello";
    foo.baz = foo.baz ~ " World!";
    foo.faz = 250 + foo.bar;

    foo.bar2 = new Bar;
    foo.bar2.boo = 200;

    import std.stdio;

    writeln(foo.bar);
    writeln(foo.baz);
    writeln(foo.faz);
    writeln(foo.bar2.boo);