const and immutable objects

[Jeremie Pelletier]

Andrei Alexandrescu Wrote:

> Jeremie Pelletier wrote:
> > Graham St Jack Wrote:
> > 
> >> On Sun, 30 Aug 2009 21:28:18 -0400, Jeremie Pelletier wrote:
> >> 
> >> 
> >>> I agree that D lacks a mechanism to separate the object from it's
> >>>  reference. Maybe syntax like the following could be used to
> >>> apply the storage class to the object value, and not the
> >>> reference value:
> >>> 
> >>> class Foo; void bar(in Foo& foo) {}
> >>> 
> >>> It's quite ugly and C-like, but that's the first thing that came
> >>> to mind. The reference value is unique to the current method and
> >>> shouldn't share the same storage qualifiers as it's referenced
> >>> memory.
> >> I think the time for pining over this particular syntax feature of
> >> D is over - as nice as it would be to be able to fix the problem in
> >> the language, it would be too disruptive right now.
> > 
> > I think it would be better to fix it in D2  instead of patching a
> > language design flaw with a template. It wouldn't be the first time
> > D2 has changes that breaks existing code anyways (and the upcoming
> > T[new] will definitely break a lot of code, so does shared when it
> > works, etc), so it would be less disruptive to do it now than never
> > do it.
> 
> I agree with the sentiment. The issue is, however, that the change adds 
> a fair amount of complexity to the const system for an arguably 
> not-often-used need.
> 
> Andrei

Correct me if I'm wrong, but I don't see how complex that could be. I assume the compiler already makes the difference between the reference value and the referenced object, all that needs to be done is to reflect that view in the syntax.

Maybe a .ref property?

class A {}
void foo(in A a) {
    a = new A(); // fail, cannot modify const
    a.ref = new A(); // ok, only reference value is modified
}

If you want to make the reference immutable, you can use the .ref on the class identifier:

const(A.ref)[] AList; // slice of const references to A

It may not be perfect, but I do firmly believe that the D syntax needs a mechanism to separate references from objects, even if rarely used, I can think of at least 15-20 places in my code I had to use workarounds for such cases.

I don't think A* should be used since that is a pointer to an object reference, it would break too much code and be incredibly hard to track back. A& looks nice because that's how references are already handled in C++, and we'd  get const(A)& the same way we get const(int)*.