On Tuesday, 22 November 2022 at 12:27:41 UTC, claptrap wrote:
> Why not an error if it's ambiguous? There are ways to specify which you want if needed. And its probably unlikely enough that occasionally having to specify the enum name is not anything to be concerned about.

Error on ambiguity can break existing code. For example, this currently compiles, but would become ambiguous if we added enum type inference using .identifier syntax:

    enum E { x = 123 }
    int x = 456;
    static assert(.x == 456);

If we wanted to avoid breaking existing code, we would have to ensure that module-scope lookup *always* took precedence over enum member lookup.

Of course, the module scope .identifier syntax is not very widely used in the first place, so maybe a small risk of breakage is worth the benefit of nice syntax for enum members.

On 11/22/2022 10:25 AM, Adam D Ruppe wrote:
> On Tuesday, 22 November 2022 at 18:13:00 UTC, Walter Bright wrote:
>> It's the old tradeoff problem. You can make the bathroom bigger or the closet bigger, but not both.
> 
> my point is just your statement that nobody ever complained about implicit(this) is demonstrably false.

There's always somebody :-)

On 11/22/2022 10:26 AM, Adam D Ruppe wrote:
> On Tuesday, 22 November 2022 at 18:16:43 UTC, Walter Bright wrote:
>> compiles successfully and when run prints:
> 
> Did you implement the implicit with?
> 
> The point is that proposal will introduce a regression with that code.

I am not seeing where or how.

On 11/22/22 1:16 PM, Walter Bright wrote:
> On 11/21/2022 5:41 PM, Timon Gehr wrote:
>> On 22.11.22 01:49, Walter Bright wrote:
>>> On 11/20/2022 1:58 PM, Timon Gehr wrote:
>>>> On 20.11.22 22:32, Walter Bright wrote:
>>>>>
>>>>> But yes, it would be a (small) breaking change.
>>>>
>>>> I really wouldn't want to run into this:
>>>>
>>>> ```d
>>>> enum Role{
>>>>      guest,
>>>>      member,
>>>>      developer,
>>>> }
>>>>
>>>> void main(){
>>>>      Role r;
>>>>      writeln(r); // error
>> (Should perhaps be auto s = to!string(r);)
>>>> }
>>>> ```
>>>>
>>>> Too messy for me, but up to you.
>>>
>>> I'm not seeing where the shadowing is?
>>
>> That's indeed basically the point. It's invisible.
> 
> This code:
> 
> ---
> import std.stdio;
> 
> enum Role{
>       guest,
>       member,
>       developer,
> }
> 
> void main(){
>       Role r;
>       writeln(r); // error
> }
> ---
> 
> compiles successfully and when run prints:
> 
> guest
> 


To spell it out, when you write `case member:` what does `member` refer to? It currently, in the implementation of Phobos refers to the `member` iteration variable of the foreach inside to!string:

```d
foreach(member; EnumMembers!E) {
```

But if an implicit `with(Role)` is added to the case clause, now it only ever refers to `Role.member`. Essentially, you will end up with a switch that looks like:

```d
switch(e) {
   case Role.member: ...
   case Role.member: ...
   case Role.member: ...
   default: ...
}
```

Which will then be a compiler error.

The fix would be to rename the iteration variable to something the user couldn't possibly use. It's not pretty.

-Steve