Convert number to enum

This crate provides a derive macro to generate a function for converting a primitive integer into the corresponding variant of an enum.

The generated function is named n and has the following signature:

rust impl YourEnum { pub fn n(value: Repr) -> Option<Self>; }

where Repr is an integer type of the right size as described in more detail below.

Example

```rust use enumn::N;

[derive(PartialEq, Debug, N)]

enum Status { LegendaryTriumph, QualifiedSuccess, FortuitousRevival, IndeterminateStalemate, RecoverableSetback, DireMisadventure, AbjectFailure, }

fn main() { let s = Status::n(1); assert_eq!(s, Some(Status::QualifiedSuccess));

let s = Status::n(9);
assert_eq!(s, None);

} ```

Signature

The generated signature depends on whether the enum has a #[repr(..)] attribute. If a repr is specified, the input to n will be required to be of that type.

```rust

[derive(enumn::N)]

[repr(u8)]

enum E { /* ... */ }

// expands to: impl E { pub fn n(value: u8) -> Option { /* ... */ } } ```

On the other hand if no repr is specified then we get a signature that is generic over a variety of possible types.

rust impl E { pub fn n<REPR: Into<i64>>(value: REPR) -> Option<Self> { /* ... */ } }

Discriminants

The conversion respects explictly specified enum discriminants. Consider this enum:

```rust

[derive(enumn::N)]

enum Letter { A = 65, B = 66, } ```

Here Letter::n(65) would return Some(Letter::A).

License

^{Licensed under either of Apache License, Version
2.0 or MIT license at your option.}

_{Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
be dual licensed as above, without any additional terms or conditions.}