Allow auto x = MyEnum.defaultValue in default parameters

[quickfur]

Currently the syntax is needlessly repetitive:

auto myFunc(MyEnum e = MyEnum.defaultValue) { ... }

Why should we repeat MyEnum twice when the type of the default value already makes the type unambiguous? I propose the syntax:

auto myFunc(auto e = MyEnum.defaultValue) { ... }

Much more DRY.

[adamdruppe]

Yeah, I'd like to do something about things at the call site too. Like just yesterday I wrote a thing like

foo(Thing.Member(5, Thing.Member.Type.foo))

and it feels silly since it knows it is a Thing.Member when calling foo.... and it knows it is a Thing.Member.Type when doing the enum.

[quickfur]

Yeah I remember discussing this in the forums a while back. Probably on multiple occasions. Basically, it would be nice to have some kind of abbreviation to get rid of all those explicit enum FQNs. Either an implicit with(...) in parameter context, or some kind of shorthand for "the enum type of the current parameter".

Same could be applied to switch statements, which have Java levels of verbosity right now. Ick.

[ntrel]

foo(Thing.Member(5, Thing.Member.Type.foo))

If _ meant the expected type, the above could probably be written:
foo(_(5, _.foo))

For overloads that might not work though.

[adamdruppe]

Yeah, something like that is what I want to see (though not _, that's already a legal name, but something like that),

[adamdruppe]

Worth noting that __ is a reserved name...

[ntrel]

It might work to only allow _ for expected type if it would otherwise be unresolved. E.g. if _ is already in scope, it continues to have the existing meaning. __ or something else would work too.

[andrey-zherikov]

Why should this be limited to enums?
Can

auto myFunc(auto e = <expression>) { ... }

be an equivalent to

auto myFunc(typeof(<expression>) e = <expression>) { ... }

for any expression?

[adamdruppe]

yeah if we went with this approach, i think this is the way to do it, follow the same rules just like any other auto variable.

[quickfur]

This approach would be my preference.

[adamdruppe]

I think my preference is still a kind of type inference on the other side though. So instead of

auto x = EnumType.foo;

you could do

EnumType x = MAGIC.foo;

or something. though both can exist just fine, it does in local vars.

[adamdruppe]

There's an open PR upstream for yet another proposal:
https://github.com/dlang/dmd/pull/16161/files

I don't think this is preferable to any of the other things but probably worth looking at since we can pull it too.