On Thursday, 27 June 2013 at 00:53:48 UTC, Jonathan M Davis wrote:
It looks to me like your code is fundamentally different from
the OP's example
rather than being a simplification of the original code. In the
OP's example,
the variable being mutated is a module-level variable, so the
immutability of
the object is irrelevant when its member function is called
(since it's not
the object itself which is being mutated). It also has nothing
to do with
construction.
Your example, on the other hand, is showing a bug with regards
to constructing
immutable objects in that the object doesn't actually become
immutable until
it's fully constructed, and the compiler isn't catching
something which then
violates the impending immutability.
I don't see the fundamental difference. In both versions:
- An immutable struct instance is constructed.
mine: immutable TplPoint my = TplPoint(42);
OP: const TplPoint!float my = TplPoint!float(42, 23);
Note that this does not set my._point to Point(42, 23).
- The constructor stores a mutable pointer to its contents in
module scope.
mine: point = &_point;
OP: points ~= &this._point;
- Via that mutable pointer the data is altered.
mine: *point = 13;
OP: a bit more convoluted, TplPoint.ptr does the nasty work, but
it could just as well be in main: points[someid].x = somevalue;
=> Immutability broken.