Will D always have a way to rebind an arbitrary data type?

[Paul Backus]

On Monday, 20 September 2021 at 08:43:48 UTC, FeepingCreature 
wrote:
> I'm trying to get a utility type `HeadMutable` merged in an 
> internal utility library,
> and one of the points of criticism in review is that the 
> mechanism I'm using (Turducken, if you remember 
> https://forum.dlang.org/thread/ekbxqxhnttihkoszzvxl@forum.dlang.org ) is extremely hacky; even though all parts of it are probably technically deliberately added to the language, it seems they add up to a pretty evil backdoor in the type system.

And indeed `Turducken` as presented in that post is unsound, 
since it allows `@safe` code to observe mutation of `immutable` 
data:

     void main() @safe
     {
         Turducken!(immutable(int)) td;
         td.bind(123);
         (ref immutable(int) value) {
             assert(value == 123);
             td.bind(456);
             assert(value == 123); // kaboom
         }(td.value);
     }

(Runnable: https://run.dlang.io/is/xCjYIz)

Because D does not have any notion of exclusive references (like 
Rust's `&mut`), the container has to assume that when `bind` is 
called, there may be outstanding references to the contained 
value. Which means that the call to `moveEmplace` cannot actually 
be `@trusted` unless the value is mutable.

So, at the very least, this has to be `@system`. Whether it's 
legitimate even then is a deeper question--if you mutate 
`immutable` data in the woods and nobody hears it, does it cause 
undefined behavior?