enum_from_variant 0.1.0

A Rust macro to generate From<T> trait implementations for enum variants, simplifying error conversions and enum mapping.
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

`enum-from-variant` crate provides the EnumFromVariant macro, which simplifies the generation of the From<T> trait for converting one enum variant to another enum variant. This is particularly useful when you need to handle error conversions or map different enum types in your Rust code.

### USAGE:

Consider the following example where we convert between different enum types using the EnumFromVariant macro:

```rust
use enum_from_variant::EnumFromVariant;
use derive_more::Display;

#[derive(Debug, EnumFromVariant)]
pub enum MainError {
    #[enum_from_variant("NetworkError")]
    Network(String),
    #[enum_from_variant("DatabaseError")]
    Database(DatabaseError),
}

#[derive(Debug, Display)]
pub enum NetworkError {
    Timeout(String),
}

#[derive(Debug, Display)]
pub enum DatabaseError {
    ConnectionFailed(String),
}

fn network_request() -> Result<(), MainError> {
    Err(NetworkError::Timeout("Network timeout".to_string()).into())
}

fn main() {
    match network_request() {
        Ok(_) => println!("Request succeeded"),
        Err(e) => println!("Error: {:?}", e),
    }
}
```

### Limitations
`Current Support`: The macro only supports enum variants with basic inner types like String and other enums.
`Unsupported Types`: Tuple variants, struct variants, and more complex inner types are not supported at this time.