mutable keyword

[Jonathan M Davis via Digitalmars-d-learn]

On Saturday, May 21, 2016 17:15:16 Jack Applegame via Digitalmars-d-learn 
wrote:
> On Friday, 20 May 2016 at 20:46:18 UTC, Jonathan M Davis wrote:
> > Casting away const and mutating is undefined behavior in D. No
> > D program should ever do it.
>
> Really? Mutating immutable is UB too, but look at
> std.typecons.Rebindable.

Rebindable is in kind of a weird grey area. It involves a union, not
casting, and it's only ever mutating the class reference, not the object
itself. Certainly, if it mutated the object, it would be undefined behavior,
but it's just mutating the reference - but then again, the type system
itself doesn't really differentiate between the two. So, I suspect that what
it comes down to is that Rebindable is doing something that you really
shouldn't, but because it's using a union rather than a cast, and it's so
limited in what it's mutating, its behavior is effectively defined in the
sense that the compiler has no leeway, but's probably still technically
undefined. I don't know what Walter would say though. Certainly, if casting
were involved, it would be undefined behavior without question, and it's not
the sort of thing that you should be doing in your own code.

So, Rebindable may actually be breaking the rules, but it's so useful that
we really have no other choice as long as there isn't a solution in the
actual language, and it's so limited in how it goes about it, that there's
really no way that it won't work even if it's not technically valid.

Personally, I think that what Rebindable has to do internally to work is the
biggest strike against it, but I doubt that it's enough to convince Walter
that we need a proper in-language solution given how much of a horrid pain
it supposedly is to sort it out in the compiler.

- Jonathan M Davis