D doesn't have logical const, but sometimes it is useful,
especially with lazy initialization of a field, and we can kinda
fake it with casts or with global variables. Modifying an
immutable object is undefined behavior, so how can we avoid that,
and if not, try to minimize the problems in practice?
Using global variables to store local state is kinda silly, it
seems to me that doing a AA lookup kinda defeats the point of
caching in the first place, so I want to focus on the cast method.
So:
* should we always wrap the write in a synchronized block to
minimize the chances that we'll have thread problems with
implicitly shared immutable things passed as const? What's the
best way to do this btw?
* should objects with logical const methods deliberately not
provide immutable constructors to prevent them from being
immutable? Would this actually work?
* Anything else that is likely to come up?
