Re: Why can't you create a out of order subtype?

[Robert A Duff <bobduff@shell01.TheWorld.com>]

brett_gengler@yahoo.com writes:

> I created a type whose order can not be rearranged and I want to create
> a subtype of that type.  So,
> 
> type msg is ( msg_a, msg_b, msg_c, msg_d, msg_e);
> 
> subtype vowel_msg is msg (msg_a, msg_e); --wrong, but why?

Because Jean Ichbiah said so.  ;-)

> Is it true that I can't define a a subtype that's not a ordered
> subrange of a type?

It's a reasonable thing to want, but Ada does not support it.

>...My issue is that I want to enforce the subtype at
> compile time instead of creating an array of booleans and doing a run
> time check.

But subtypes in Ada are checked at run time.  So if the language
supported what you want, it would still be a run-time check.
An implicit run-time check, as opposed to the explicit code
you mention below.  It has to be a run-time check, in the general
case.

There are some cases where these things can be checked at compile time,
and some compilers give warnings in those cases.  But compilers vary in
how smart they are about warnings, and the absence of warnings does not
imply an absence of errors in the code.

>... (This is for an interface and I don't trust people to send
> me the right types).
> 
> vowel_filter is array(msg) of Boolean := (msg_a => True, msg_e => True,
> others => False);  --yuck.

You can say (msg_a | msg_e => True, others => False),
which is a little bit more concise.  You can also decide whether
to Pack the array.

But "others" is usually evil.  If you add "msg_i" later, it will be
picked up by that others.  But if you spell out "msg_b|msg_c|msg_d" now,
then when you add msg_i, you'll get a compile-time error reminding you
to decide whether or not it's a vowel.

> Another option that I think is much, much worse then the boolean array
> would be create an overloaded type...
> 
> type msg is ( msg_a, msg_b, msg_c, msg_d, msg_e);
> type vowelmsg ( msg_a, msg_e);
> 
> But as you know, msg.msg_e = 4 and vowelmsg.msg_e = 1 so an unchecked
> conversion is wrong on so many levels.

I agree -- that's not a very good solution.

> Am I screwed?  Should I just implement a boolean array and shut up
> about it?

You should probably implement the boolean array.  But you don't have to
shut up about it.  ;-)

In this particular case, you can do:

    subtype Consonant_Msg is Msg range msg_b..msg_d;
    if blah not in Consonant_Msg then ...

but there's no general way to get arbitrary subtypes of an enumeration
type.

- Bob