Re: Question about default discriminants and mutable objects.

[Gene <gene.ressler@gmail.com>]

On May 5, 8:41 pm, "Peter C. Chapin" <pcc482...@gmail.com> wrote:
> Hopefully I can ask this question clearly...
>
> I understand that an instance of a type with default discriminants can be
> mutated (here I mean have its discriminant changed) via assignment. It seems
> like the most effective way for a compiler to support that ability is to
> always allocate enough memory for the object to account for all possible
> discriminant values. Mordechai Ben-Ari pretty much says this explicitly in
> his book "Ada for Software Engineers."
>
> I also understand that an instance of a type without default discriminants
> can't be mutated in this way (that is, by assignment). If a new value is
> assigned to the object with the wrong discriminant the result is
> Constraint_Error. This would allow the compiler to allocate just the memory
> necessary for that particular discriminant value used to initialize the
> object since there would never be a (successful) attempt to stuff a larger
> object into that space.
>
> It seems like conceptually the issue of default discriminants and mutability
> (in the sense I mean here) are independent. One could imagine some currently
> non-existent syntax that would allow the programmer to mark a type
> declaration so that the compiler allowed discriminant values to be changed
> via assignment without leaning on the mechanism of default discriminants.
> Furthermore one could imagine treating default discriminants as 100%
> syntactic sugar and not endowing them with any special semantics regarding
> mutability.
>
> Okay, so my question is: what was the rationale behind combining the notion of
> default discriminants with the notion of mutability? Is there some subtle
> technical reason why they must go together? I don't have pressing need to
> know... I'm curious and I'm trying to deepen my understanding of this topic.
>
I don't have any special knowledge, and I also believe there is no
really good reason for the connection.

But I've always satisfied my own curiosity about this with the
rationale that it's all about declarations that look like

x : Foo;

where Foo is a discriminated type.

For Foo to be well-defined, it must have a default descriminant
value.  Otherwise it is no type at all.

Yet the syntax here connotes that any value of type Foo ought to be
assignable to x in the future.  It would be an opaque gotcha if a
future assignment to x with a value having other than the default
discriminant caused a run-time exception.

The conclusion is that x ought to be mutable.  Viola!  Discriminated
types with default discriminant values are mutable.

And if you're going to admit non-mutable discriminant types at all,
then it's something like logical for all the rest to be these.

Tortured, I agree...  One can almost hear the design-by-committee in
progress.