On 11/18/2022 6:06 PM, ryuukk_ wrote:
> MySuperLongType flag = MySuperLongType.ValueA | MySuperLongType.ValueB | MySuperLongType.ValueC | MySuperLongType.ValueD | MySuperLongType.ValueE | MySuperLongType.ValueF | MySuperLongType.ValueG;
> 
> // vs
> 
> MySuperLongType flag = .ValueA | .ValueB | .ValueC | .ValueD | .ValueE | .ValueF | .ValueG;

with (MySuperLongType)
MySuperLongType flag = ValueA | ValueB | ValueC | ValueD | ValueE | ValueF | ValueG;

On 19.11.22 03:54, Walter Bright wrote:
> With the syntax $e to look up an enum member, the compiler will need to search *every* enum that is in scope. Since one of D's strengths is whole program compilation, this can be slow. To speed that up, it will likely require that the compiler maintain a hash table of all the enum fields.
> 
> I.e. a parallel symbol table will have to be maintained alongside the regular symbol table. 

Not true. E.g. see my example with delegates.

On Saturday, 19 November 2022 at 02:57:27 UTC, Walter Bright wrote:
> with (MySuperLongType)
> MySuperLongType flag = ValueA | ValueB | ValueC | ValueD | ValueE | ValueF | ValueG;

`flag` is now inaccessible since `with` creates a new scope.

Of course, you may be able to just extend the scope to cover the usage point as well.

On 11/18/2022 7:09 PM, Adam D. Ruppe wrote:
> On Saturday, 19 November 2022 at 02:57:27 UTC, Walter Bright wrote:
>> with (MySuperLongType)
>> MySuperLongType flag = ValueA | ValueB | ValueC | ValueD | ValueE | ValueF | ValueG;
> 
> `flag` is now inaccessible since `with` creates a new scope.


True, but you could also do:

with (MySuperLongType):  // <= note colon
MySuperLongType flag = ValueA | ValueB | ValueC | ValueD | ValueE | ValueF |
 ValueG;


> Of course, you may be able to just extend the scope to cover the usage point as well.

Yup.

On 11/18/2022 7:05 PM, Timon Gehr wrote:
> On 19.11.22 03:54, Walter Bright wrote:
>> With the syntax $e to look up an enum member, the compiler will need to search *every* enum that is in scope. Since one of D's strengths is whole program compilation, this can be slow. To speed that up, it will likely require that the compiler maintain a hash table of all the enum fields.
>>
>> I.e. a parallel symbol table will have to be maintained alongside the regular symbol table. 
> 
> Not true. E.g. see my example with delegates.

I was thinking of the general case of $a being able to find member `a` among all the enums in scope.

You're referring, of course, to the "contextual" part of the DIP, where the lookup works only in a subset of cases. The contextual lookup can result in some odd cases like:

---- module A ----
    private enum E { e; };
    public void dra(E);
------------------
    import A;

    dra($e);
------------------

Is that a good thing? I'm not sure. This is also not addressed in the DIP.

Consider this:

    enum A { a; }
    enum B { a; }

    void f(A);
    void f(B);

    ...
    f($a + $a); // mentioned in the DIP as allowed
    ...

Since the DIP allows expressions containing such enum inferences, it looks like we are faced with the possibility of having to re-run the semantic pass for enum arguments for every enum overload.