Accidentally killing immutable is too easy in D (Was: cast()x - a valid expression?)

[Steven Schveighoffer]

On Wed, 01 Jun 2011 16:42:10 -0400, Nick Sabalausky <a at a.a> wrote:

> "Steven Schveighoffer" <schveiguy at yahoo.com> wrote in message
>> It gets even better:
>>
>> char[] x = "abc".dup;
>>
>> assert(is(typeof(cast(const)x) == const(char[]));
>>
>> I think you may have found a "bug" that should be a feature.  It's like
>> dmd is organically growing features that we might need ;)  Is this
>> software evolution?  Scary!
>>
>> When will dmd decide that human life is a disease to be eradicated?   
>> When
>> will the world be dominated by constinators?!!!  I fear for my children.
>>
>> All kidding aside, I actually think the syntax makes sense.  You are
>> adding/removing modifiers, so just leave the type out of it.  The only
>> drawback is, you can't do a cast directly to a tail-const array, but
>> that's not a huge deal, since const(T[]) implicitly casts to const(T)[].
>>
>> I dub this feature "Type Modifier Casting".
>>
>
> It's nice in a way, but it's all based on the way cast handles modifiers.
> And I've always been a bit unconfortable with how that's handled (In  
> fact, I
> was just thinking about this yesterday). Specifically, it seems extremely
> bad that it's so incredibly easy to accidentaly cast away things like  
> const
> and immutable:

Yes, it would be nice to have the equivalent of static_cast (which doesn't  
allow removing const in C++).  I think however, we don't need compiler  
support for such things.  We can probably do this via metaprogramming.

However, having the ability to cast away or to  
const/immutable/shared/inout is very close to const_cast in C++.  It fixes  
the problem where you just want to cast away const but inadvertently end  
up switching the type.

We also need a static_cast for objects.  Right now, casting to a derived  
object involves a dynamic lookup, but if you know that the dynamic lookup  
is not necessary, a cast which does not do a dynamic lookup can be much  
faster.

For example, I could have a class A that contains a member of type X.   
Then you implement B : A and Y : X such that B's member X is always  
actually a Y.  Re-storing the Y as another member is wasteful, and so is  
doing a dynamic cast for every usage of the member.

> Of course, you can probably use some fancy helper templates to make sure  
> you
> preserve all modifiers. But needing to do so is just asking for  
> mistakes: it
> seems like a huge violation of "make the right way easy, and the wrong  
> way
> hard".

I get what you are saying.  I would be happy if default cast didn't allow  
casting away const or immutable, but I think we would have a difficult  
time introducing such a change.

Note however, C++ has good success with static_cast vs the old C-style  
cast (which is supported), so there is hope.  The more troubling thing is  
when you *want* to do a dynamic cast (which can only be done via the  
cast(X) style), you can inadvertently remove const or immutable.

-Steve