backend 0.1.6

A macro library for backend agnostic design
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

#[macro_use]
extern crate backend;

pub enum GrownUps {
    Homer,
    Marge
}

#[derive(Eq, PartialEq, Debug)]
pub enum Kids {
    Bart,
    Lisa,
    Maggie,
}

pub enum TheSimpsons {}

pub trait HasParents: OfBackend {
    fn father(&self) -> Self::Father;
    fn mother(&self) -> Self::Mother;
}

pub trait HasChildren: OfBackend {
    fn coolest(&self) -> Self::Kids;
    fn smartest(&self) -> Self::Kids;
    fn cutest(&self) -> Self::Kids;
}

// Creates a `Backend` and `OfBackend` trait.
backend!(
    Father [HasChildren],
    Mother [HasChildren],
    Kids [HasParents]
);

impl HasParents for Kids {
    fn father(&self) -> GrownUps { GrownUps::Homer }
    fn mother(&self) -> GrownUps { GrownUps::Marge }
}

impl<T> HasChildren for T
    where T: OfBackend<Kids = Kids>,
{
    fn coolest(&self) -> Kids { Kids::Bart }
    fn smartest(&self) -> Kids { Kids::Lisa }
    fn cutest(&self) -> Kids { Kids::Maggie }
}

backend_impl!(
    TheSimpsons {
        Father, Mother = GrownUps,
        Kids = Kids
    }
);

// `HasParents` inherits `OfBackend` such that it gets the associated types.
fn father<T: HasParents>(v: T) -> T::Father { v.father() }

pub fn main() {
    let homer = father(Kids::Bart);
    let marge = Kids::Lisa.mother();
    assert_eq!(homer.coolest(), marge.coolest());
    assert_eq!(homer.cutest(), Kids::Maggie);   
}