• Ashish Myles (28/28) Apr 30 2011 I saw examples in the D Programming Language book (Page 256) where
• Jason House (3/4) May 01 2011 Allowing this is a bug. File it in bugzilla.

Ashish Myles <marcianx gmail.com> writes:

I saw examples in the D Programming Language book (Page 256) where 
opAssign() took a ref argument instead of a const ref. So I figured I 
would test it out and see if the compiler complains if I try to assign a 
const or immutable struct to another one.

import std.stdio;

struct Foo
{
     auto ref opAssign(ref Foo s)
     {
         s.x = 4; // modifying mutable object !!!
         x = s.x;
         return this;
     }

     private int x = 0;
}

void main(string[] args)
{
     immutable(Foo) foo = Foo();
     auto foo2 = Foo();
     writefln("(immutable!) foo.x = %s", foo.x); // prints 0
     foo2 = foo; // allowed immutable RHS ???
     writefln("(immutable?) foo.x = %s", foo.x); // prints 4
}

Turns out it doesn't, and it seems to violate immutability. Is there 
something I am misunderstanding here?

The example above compiles with both gdc and dmd for D2. It also works 
with immutable replaced by const.

Ashish

Jason House <jason.james.house gmail.com> writes:

Ashish Myles Wrote:

      foo2 = foo; // allowed immutable RHS ???

Allowing this is a bug. File it in bugzilla.

Unfortunately, lazy objects "mess up" the expected const correctness of Object.
Even if they are logically const, lazy objects can't always be passed as const.