On Sunday, 1 March 2015 at 01:40:40 UTC, Andrei Alexandrescu
wrote:
We have a few candidates for solutions, but wanted to open with
a good discussion first. So, how do you envision a way to
define and access mutable metadata for objects (including
immutable ones)?
Andrei
I don't think const or immutable intrusive-reference-counted
classes is a feasible idea.
I understand the motivation: we want to dynamically allocate a
class instance, initialize it and never mutate it again, and pass
it around freely; *without* using tracing GC. Having it typed as
immutable helps code readability and whatnot.
However, AFAICS, it comes with a serious problem. Immutable
objects are freely passable between threads, so surely an
immutable RC object would need atomic counting just like a shared
RC object, but unlike shared, immutable does not necessarily
express the intent of sharing between threads; the immutable RC
object could easily be counting atomically for nothing.
There might be other problems, such as problems regarding ROM.
This is not a problem with reference-counting as a whole but with
intrusive reference-counting. With RefCounted,
immutable(RefCounted!T) makes no sense, but RefCounted!(immutable
T) does. It's also neatly composable;
shared(RefCounted!(immutable T)) makes sense too.
I wish we had external, composable reference-counting for class
instances. I know why that's problematic, so sorry for posting
without any suggestion on how to proceed...
