num_enum 0.1.1

Procedural macros to make inter-operation between primitives and enums easier.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

num_enum
========

Procedural macros to make inter-operation between primitives and enums easier.

[![crates.io](https://img.shields.io/crates/v/num_enum.svg)](https://crates.io/crates/num_enum)
[![Documentation](https://docs.rs/num_enum/badge.svg)](https://docs.rs/num_enum)
[![Build Status](https://travis-ci.org/illicitonion/num_enum.svg?branch=master)](https://travis-ci.org/illicitonion/num_enum)

Turning an enum into a primitive
--------------------------------

```rust
extern crate num_enum;
use num_enum::IntoPrimitive;

#[derive(IntoPrimitive)]
#[repr(u8)]
enum Number {
    Zero,
    One,
}

#[test]
fn convert() {
    let zero: u8 = Number::Zero.into();
    assert_eq!(zero, 0u8);
}
```

`num_enum`'s `IntoPrimitive` is more type-safe than using `as`, because `as` will silently truncate - `num_enum` only derives `From` for exactly the discriminant type of the enum.

Turning a primitive into an enum with try_from (nightly only)
-------------------------------------------------------------

```rust
#![feature(try_from)]

extern crate num_enum;

use num_enum::TryFromPrimitive;
use std::convert::TryInto;

#[derive(Debug, Eq, PartialEq, TryFromPrimitive)]
#[repr(u8)]
enum Number {
    Zero,
    One,
}

#[test]
fn convert() {
    let zero: Number = 0u8.try_into().unwrap();
    assert_eq!(zero, Ok(Number::Zero));

    let three: Result<Number, String> = 3u8.try_into();
    assert_eq!(three, Err("No value in enum Number for value 3".to_owned()));
}
```

Turning a primitive into an enum (stable rust)
----------------------------------------------

Unfortunately, `try_from` is not yet stable (see https://github.com/rust-lang/rust/issues/33417), so `num_enum` can also derive a custom trait which can be used in stable rust. It's a little ugly, but it does the job! It adds a function called `try_into_{enum_name}` which you can use. If you're converting outside of the module where the enum was defined, you may also need to `use your_module::TryInto{enum_name};`.

```rust
extern crate num_enum;

use num_enum::CustomTryInto;

#[derive(Debug, Eq, PartialEq, CustomTryInto)]
#[repr(u8)]
enum Number {
    Zero,
    One,
}

#[test]
fn convert() {
    let zero: Result<Number, String> = 0u8.try_into_Number();
    assert_eq!(zero, Ok(Number::Zero));

    let three: Result<Number, String> = 3u8.try_into_Number();
    assert_eq!(three, Err("No value in enum Number for value 3".to_owned()));
}
```

Optional features
-----------------

Some enum values may be composed of complex expressions, for example:

```rust
enum Number {
    Zero: (0, 1).0,
    One: (0, 1),1,
}
```

To cut down on compile time, these are not supported by default, but if you enable the `complex-expressions` feature of your dependency on `num_enum`, these should start working.