Discriminant name must be alone

[Michal Nowak <vinnie@inetia.pl>]

Hello all,

Digging around (teaching myself and experimenting with Ada)
I wandered to RM 3.8 (12):

"A name that denotes a noninherited discriminant is allowed within
the declaration of the type, but not within the discriminant_part.
If the discriminant is used to define the constraint of a component,
the bounds of an entry family, or the constraint of the parent subtype
in a derived_type_definition then its name shall appear alone as a
direct_name (not as part of a larger expression or expanded name).
A discriminant shall not be used to define the constraint of a scalar
component."

At this point (maybe later I will get deeper in other uses) I'm 
thinking about using a discriminant to define the constraint of
a component. This rule forbids me to do something like this:

type R (Start_Ind : Positive) is
   record
      Table : Some_Array_Type (1 .. Start_Ind + 10);
   end record;

and like this:

type R (Start_Ind : Positive) is
   record
      Table : Some_Array_Type (Start_Ind .. Start_Ind + 10);
   end record;

I may live with this, but I don't like to blindly follow
the rules, I'm a bit more curious :-). AARM (12a):
"Reason: The penultimate restriction simplifies implementation,
and allows the outer discriminant and the inner discriminant or
bound to possibly share storage."
gives me some explanation to this. In fact, in my first example,
if the array was constrained by (1 .. Start_Ind), Start_Ind may
be shared by record and array, but if it is (1 .. Start_Ind + 10)
it cannot. In the second example Start_Ind may be shared, even
if it breaks the rule two times, but that's only a specific example
and does not shows my point.
My questions: Why is this rule so restrictive? Is the (potential)
possibility or simpler implementation only reason for it? Maybe
there are historical (I may be too young to know them - I'm just
freshly after studies) or so? If someone has any pointers I'll be
glad to read them. 
From the other side - if the possibility of shared storage is
the only one, maybe it would be reasonable to weaken this
rule in next Ada revision, to allow uses like above? So the
memory usage depends on how discriminants are used. Are there
any uses (examples), where it is reasonable to keep this rule
in current form?

Regards,
   - Michal



-- -----------------------------------------------------------------
--   ___        _
--  / _ \      | |                      I Choose Ada:
-- | |_| |  ___| |   _____   The Most Trusted Name in Software (TM)
-- |  _  | | __  |  | __  | 
-- |_| |_| |_____|_ |_____|_ http://www.adaic.org/whyada/choose.html
--
-- -----------------------------------------------------------------