Convert number to enum
======================
[
](https://github.com/dtolnay/enumn)
[
](https://crates.io/crates/enumn)
[
](https://docs.rs/enumn)
[
](https://github.com/dtolnay/enumn/actions?query=branch%3Amaster)
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;
}
```
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>(value: REPR) -> Option {
/* ... */
}
}
```
## Discriminants
The conversion respects explicitly 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.