typesum 0.2.0

Utilties for enums, targeted at sum types
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

# TypeSum

Utilities for working with enums, primarily aimed at sum types.

## What's in it

### `#[sumtype]`: Generate all the functions and impls you could ever need for a sum type

If you want the full list it's in the [docs for the attribute](typesum::sumtype)

```rust
use typesum::{sumtype, TryIntoError};
#[sumtype]
#[derive(Debug, PartialEq, Eq)]
enum MyT {
    Int(i64),
    Bool(bool),
}
let mut v = MyT::Int(6);
assert!(v.is_int());
assert_eq!(v.as_int(), Some(&6));
assert_eq!(v.as_int_mut(), Some(&mut 6));
assert_eq!(v.try_as_int(), Ok(&6));
assert_eq!(v.try_as_int_mut(), Ok(&mut 6));
assert_eq!(v.try_as_bool(), Err(TryIntoError::new("MyT", "Int", "Bool")));
assert_eq!(MyT::from(false), MyT::Bool(false));
assert_eq!(MyT::from(false).try_into_int(), Err(TryIntoError::new("MyT", "Bool", "Int")));
```

Individual variants can be ignored with `#[sumtype(ignore)]`

```rust,compile_fail
use typesum::sumtype;
#[sumtype]
enum MyT {
    Int(i64),
    #[sumtype(ignore)]
    Empty,
}
let v = MyT::Empty;
v.as_empty(); // doesn't exist
```

It can even work with overlapping types

```rust
use typesum::sumtype;
#[sumtype(from = false, impl_try_into)]
#[derive(Debug, PartialEq, Eq)]
enum Overlap {
    #[sumtype(from)]
    Int1(i64),
    Int2(i64),
    Int3(i64),
    #[sumtype(from)]
    Bool1(bool),
    Bool2(bool),
}
assert_eq!(Overlap::from(0), Overlap::Int1(0));
assert_eq!(Overlap::Int3(5).try_into(), Ok(5));
assert_eq!(Overlap::from(false), Overlap::Bool1(false));
assert_eq!(Overlap::Bool2(false).try_into(), Ok(false));
```

### `#[kinded]`: Generate kind aliases for an enum

```rust
use typesum::kinded;

#[kinded]
enum LookAtMe {
    Hello { world: String },
    ImAUnit,
    OrPerhapsATuple(i64, u32),
}
let look = LookAtMe::ImAUnit;
assert_eq!(look.kind(), LookAtMeKind::ImAUnit);
```