Re: Logical const

[Simen kjaeraas]

Jesse Phillips <jessekphillip...@gmail.com> wrote:
In fact, couldn't opAssign be


     ref opAssign(U)(auto ref U v)  if(Unqual!U == U)
     {
         return mutable() = v;
     }

This way only mutable references are only ever assigned to it? Then it  
can be marked as @trusted and used in safe code as it will never cause  
the program to crash?

Indeed it could. This brings me to this code:


struct Mutable( T ) if ( is( T : Unqual!T ) ) {
    private T _payload;

    this( Unqual!T t ) {
        _payload = t;
    }

    @trusted @property ref T get( )( ) const {
        T* p = cast( T* )&_payload;
        return *p;
    }
    alias get this;

    @trusted ref opAssign( U )( auto ref U u ) const if ( is( Unqual!U ==  
U ) && is( U : T ) ) {
        T* p = cast( T* )&_payload;
        return *p = u;
    }

    bool opEquals( )( ref const Mutable other ) const {
        return _payload == other._payload;
    }

    bool opEquals( U )( auto ref U other ) const if ( is( U : T ) || is( T  
: U ) ) {
        return _payload == other;
    }
}

It works in many cases, but not for function calls:

void bar( int n ) {}

class A {
    Mutable!int n;
}

A a = new A;
bar(a.n);//Error: function bar (int n) is not callable using argument  
types (const(Mutable!(int)))


--
Simen