transitive 0.4.3

Transitive derive macros for Rust.
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

[![Crates.io](https://img.shields.io/crates/v/transitive.svg)](https://crates.io/crates/transitive)

# transitive
Transitive converions through derive macros for Rust.

## Rationale:
Assume you have types `A`, `B` and `C` with the following, already implemented, conversions:
- `A -> B`
- `B -> C`

Sometimes it might be desirable to have an `A -> C` implementation which could easily be represented as `A -> B -> C`.

That is precisely what this crate does. Through the `TransitiveFrom` and `TransitiveTryFrom` derive macros, it will implement `From` or `TryFrom` respectively
for converting from/to the derived type and a target type, given a path of transitions to go through.

```rust
use transitive::TransitiveFrom;

#[derive(TransitiveFrom)]
#[transitive(into(B, C, D))] // impl From<A> for D by doing A -> B -> C -> D
struct A;

#[derive(TransitiveFrom)]
#[transitive(into(C, D))] // impl From<B> for D by doing B -> C -> D
struct B;
struct C;
struct D;

impl From<A> for B {
    fn from(val: A) -> Self {
        Self
    }
};

impl From<B> for C {
    fn from(val: B) -> Self {
        Self
    }
};

impl From<C> for D {
    fn from(val: C) -> Self {
        Self
    }
};

#[test]
fn into() {
    D::from(A);
    D::from(B);
}
```

More examples and explanations can be found in the [documentation](https://docs.rs/transitive/latest/transitive/).

## License
Licensed under MIT license (LICENSE-MIT or https://opensource.org/licenses/MIT).

## Contributing
Contributions to this repository, unless explicitly stated otherwise, will be considered licensed under MIT.
Bugs/issues encountered can be opened [here](https://github.com/bobozaur/transitive/issues)