On Thursday, 30 June 2022 at 11:03:08 UTC, bauss wrote:

SomeEnum.a | SomeEnum.b | SomeEnum.c

.a | .b | .c

SomeEnum flags = SomeEnum (a | b | c);

Why do i have to be repetitive? the goal is to not be repetitive and be cleaner

SomeEnum flags = .a | .b | .c;

The brain no longer have to read 2x the same stuff, it goes straight to the point, it is explicit and typechecked

On Thursday, 30 June 2022 at 15:42:05 UTC, ryuukk_ wrote:

SomeEnum.a | SomeEnum.b | SomeEnum.c

.a | .b | .c

SomeEnum flags = SomeEnum (a | b | c);

SomeEnum flags = .a | .b | .c;

and if you later see a line like

auto flags = .a | .b | .c;

imho it's just much harder to figure out whats going on.
i agree that a short syntax would be good. i'd prefer with() because it makes it easier to understand later.

On Thursday, 30 June 2022 at 11:32:42 UTC, ryuukk_ wrote:

set_my_flag( MySuperLongName.MyFlagA |  MySuperLongName.MyFlagB | MySuperLongName.MyFlagC | MySuperLongName.MyFlagD | MySuperLongName.MyFlagE | MySuperLongName.MyFlagF );

set_my_flag( .MyFlagA |  .MyFlagB | .MyFlagC | .MyFlagD | .MyFlagE | .MyFlagF );

Where do you want to use it where it cannot be used?

This works today:

    with(Color)
    final switch(color) {
        case red: writeln("red"); break;
    	case orange: writeln("orange");
    }

    with(MySuperLongName) set_my_flag( MyFlagA |  MyFlagB | MyFlagC | MyFlagD | MyFlagE | MyFlagF);

More clear at the cost of a few more characters to type. Quite acceptable compromise in my view.

On Thursday, 30 June 2022 at 17:15:46 UTC, ShadoLight wrote:

set_my_flag( MySuperLongName.MyFlagA |  MySuperLongName.MyFlagB | MySuperLongName.MyFlagC | MySuperLongName.MyFlagD | MySuperLongName.MyFlagE | MySuperLongName.MyFlagF );

set_my_flag( .MyFlagA |  .MyFlagB | .MyFlagC | .MyFlagD | .MyFlagE | .MyFlagF );

    with(Color)
    final switch(color) {
        case red: writeln("red"); break;
    	case orange: writeln("orange");
    }

    with(MySuperLongName) set_my_flag( MyFlagA |  MyFlagB | MyFlagC | MyFlagD | MyFlagE | MyFlagF);

Now it is harder to see the function, 'with' is nice when you need to pull in a symbol into a scope

It is not nice when you just want to call a function with your enum

Other languages who have it didn't go with a 'with' for a reason, it adds unecessary noise

You don't do:

with(int) set_my_int(5 + 6 + 7 + 8 + 9 +10);

It kills the intent to make things simpler and logical, functions expect Enum, we give its value

Function expect int? we give a value

On Thursday, 30 June 2022 at 16:25:35 UTC, The Zealot wrote:

SomeEnum.a | SomeEnum.b | SomeEnum.c

.a | .b | .c

SomeEnum flags = SomeEnum (a | b | c);

SomeEnum flags = .a | .b | .c;

auto flags = .a | .b | .c;

I already explained in earlier replies

If you use auto, how can the compiler expect you to use an enum called MyEnum? it doesn't make sense, for that case, it falls back to the current behavior, it searches for the parent scope

If no variable found, then it is compile error, undefined symbols a, b, c

On Thursday, 30 June 2022 at 20:32:49 UTC, ryuukk_ wrote:

with(int) set_my_int(5 + 6 + 7 + 8 + 9 +10);

It's funny that in fact I like this really. It's much more readable than casting to the desired type. E.g. you might have wished every literal to be float:

with(float) foo(5 + 6 + 7 + 8 + 9 + 10);

Unfortunately that doesn't work, so we have to live with

foo(cast(float)5 + 6 + 7 + 8 + 9 + 10);

or

foo(5.0f + 6 + 7 + 8 + 9 + 10);

which looks short, but you don't know if the compiler will use float or double or real because of the strange propagation rules.

or cast every literal:

foo(5.0f + 6.0f + 7.0f + 8.0f + 9.0f + 10.0f);

Much worse if you want byte:

foo(cast(byte)5 + 6 + 7 + 8 + 250);

calls foo with int :-(
Here even casting each literal doesn't work, you have to cast the result. I really wish

with(byte) foo(5 + 6 + 7 + 8 + 9 + 10);

would work.

On Friday, 1 July 2022 at 04:53:01 UTC, Walter Bright wrote:

C and D don't have an enumeration type. enum class gave C++ a somewhat type safe enumeration type. It is very useful.