enum_builder 0.1.6

Simple macros that allow building enum types from variants that can be defined in multiple dispersed files in the crate.
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

mod more_animals;

use enum_builder::{enum_builder, enum_builder_variant};
use enum_dispatch::enum_dispatch;
use more_animals::chicken::*;
use more_animals::goat::*;

#[enum_dispatch(Animal)]
trait AnimalSound {
	fn speak(&self);
}

#[enum_builder]
#[enum_dispatch]
enum Animal {}

#[enum_builder_variant(Animal)]
struct Dog {}

impl AnimalSound for Dog {
	fn speak(&self) {
		println!("The dog goes woof!");
	}
}

#[enum_builder_variant(Animal)]
struct Cow {}

impl AnimalSound for Cow {
	fn speak(&self) {
		println!("The cow goes moo!");
	}
}

#[enum_builder_variant(Animal)]
struct Fish {}

impl AnimalSound for Fish {
	fn speak(&self) {
		println!("The fish goes blub blub!");
	}
}

#[enum_builder_variant(Animal)]
pub type Snake<'a> = ();

impl<'a> AnimalSound for Snake<'a> {
	fn speak(&self) {
		println!("The snake goes hiss!");
	}
}

#[test]
fn test_enum_builder() {
	let dog: Animal = Dog {}.into();
	let cow: Animal = Cow {}.into();
	let fish: Animal = Fish {}.into();
	let snake = ().into();
	let chicken: Animal = Chicken { count: &3 }.into();
	let goat: Animal = Goat(7).into();
	let farm = vec![dog, cow, fish, snake, chicken, goat];

	for animal in &farm {
		animal.speak();
	}
}