Re: extended membership tests

[Dan <dan@irvine.com>]

On Mar 31, 10:14 pm, AdaMagica <christ-usch.gr...@t-online.de> wrote:
> On 31 Mrz., 16:33, Robert A Duff <bobd...@shell01.TheWorld.com> wrote:
>
> > For extra credit, what happens if we replace b2 with:
>
> >     b3: boolean := int_sets.to_set(new_item => x)
> >                 in int_sets.to_set(new_item => x)
> >                 or int_sets.to_set(new_item => y);
>
> OK, I'll try. We should write this as
>
>    b3: boolean :=
>    int_sets.to_set(new_item => x) in
>       int_sets.to_set(new_item => x) or int_sets.to_set(new_item =>
> y);
>
> So the right-hand side is a choice_expression of the form
> simple_expression or simple_expression.
> So if there isn't an or operator for sets (I don't know, I didn't
> check the set container), it's illegal.
> If there is one, it's a set (presumably the union) and it's the
> tested_set.
> The lhs is a simple_expression which is tagged (I presume sets are
> tagged) which must resolve to a type convertible to the tested type,
> which it is.
> Now we have an individual membership test lhs in rhs.
> The simple expression (lhs) is not equal to the value of the
> membership_choice (rhs). So the membership test returns False.
>
>    int_sets.to_set(new_item => x) in
>       int_sets.to_set(new_item => x) | int_sets.to_set(new_item => y);
>
> would return True.
>
> This doesn't seem very intuitive to me. (Provided that my reading of
> the RM is correct.)

I think it's fair to say that the proposed definition of the
membership operator to
sometimes mean "=" is counter-intuitive to just about everyone, and is
an unintended
consequence of the new syntax rules which were designed for more
complicated expressions,
such as x in 2 | 5..10.

I think it's also somewhat likely that the language will be extended
at some point to
allow the membership operator to apply to the Set containers, or
actually any "iterable" type.
AI05-0139-2 proposes to integrate iterable types with for loops, and
it would seem to be
a natural extension to similarly integrate them with membership
tests.  But if that is done,
the possible interpretation of X in Y as an equality test would be
even more confusing than
it is now (as the b3 example suggests).

Yannick suggested making X in Y illegal, when X and Y have the same
type, to avoid the
confusion.  I agree with that suggestion.

         -- Dan