Allow #derive(Default) with catch_all

[dandyvica]

Hi,

It seems that:

Attribute "catch_all" is mutually exclusive with "default"

Could you make this an option ? I'd really like to use your crate in my project, but this is a showstopper right now.

Thanks.

[urkle]

This would be a useful feature. right now I am just manually implementing default.

#[derive(IntoPrimitive, FromPrimitive)]
#[repr(i16)]
enum MyEnum {
   NoType = 0,
   Left = 1,
   Right = 2,
   #[num_enum(default)]
   Unknown = 100
}

#[allow(clippy::derivable_impls)]
impl Default for MyEnum {
    fn default() -> Self {
        MyEnum::NoType
    }
}

This allows NoType to be the default value, and Unknown to be used when an unexpected value is used. (in my use-case I could not use catch_all, but I need to differentiate between a default and an unexpected value)

Thus this should be allowed

#[derive(Default, IntoPrimitive, FromPrimitive)]
#[repr(i16)]
enum MyEnum {
   #[default]
   NoType = 0,
   Left = 1,
   Right = 2,
   #[num_enum(default)]
   Unknown = 100
}

// OR with catch_all

#[derive(Default, IntoPrimitive, FromPrimitive)]
#[repr(i16)]
enum MyEnum {
   #[default]
   NoType = 0,
   Left = 1,
   Right = 2,
   #[num_enum(catch_all)]
   Unknown(i16)
}

[illicitonion]

Sorry, I somehow missed this when it got filed.

The reason this isn't supported at the moment is the confusion it can give rise to. Effectively "default" means "this is the default variant (when constructing)", and "catch_all" means "this is the default variant (when converting)". While this can make sense, it's quite confusing to reason about, because the context of when each is the default is somewhat nuanced.

This is even more clear in @urkle's first example, where the attribute "default" is literally attached to two different variants.

If anyone can think of a nice way to make this less confusing, I'm open to exploring, but for now manually implementing Default doesn't feel like a terrible way to handle this.

[urkle]

@illicitonion I can see where the confusion can be created. I was noticing that myself as I was writing up the code today. My thoughts is that the #[num_enum(default)] should be #[num_enum(fallback)].

OR we should simply remove the ability to utilize the #[default] attribute entirely (and also drop the ::num_enum::Default since modern rust has support for that)

And the only annoying issue with manually implementing default (well, other than having to manually implement it), is that clippy wants to remove it (if you notice my overrides).