meta_tuple 0.5.0

A statically typed opaque tuple that can contain any type.
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

use std::any::Any;

use meta_tuple::{MetaAny, MetaItem, MetaTuple, impl_meta_any, meta_tuple, meta_tuple_type};

pub struct Attack;
pub struct Attacker;
pub struct Defender;

#[derive(MetaItem)]
pub struct DamageDealt(usize);

impl Attack {
    pub fn calculate_damage(&self, _: &Attacker, _: &Defender) -> usize {
        40
    }
}

pub trait CardComponent {
    fn play(&self, input: impl MetaTuple) -> impl MetaTuple;

    fn join(self, other: impl CardComponent) -> impl CardComponent
    where
        Self: Sized,
    {
        Join(self, other)
    }
}

pub struct Join<A, B>(A, B);

impl<A: CardComponent, B: CardComponent> CardComponent for Join<A, B> {
    fn play(&self, input: impl MetaTuple) -> impl MetaTuple {
        let out = self.0.play(input);
        self.1.play(out)
    }
}

impl CardComponent for Attack {
    fn play(&self, input: impl MetaTuple) -> impl MetaTuple {
        let attacker = input.get::<Attacker>().unwrap();
        let defender = input.get::<Defender>().unwrap();
        let damage_dealt = self.calculate_damage(attacker, defender);
        input.join(DamageDealt(damage_dealt))
    }
}

pub trait CardComponent2 {
    type Out: MetaTuple;
    fn play<T: MetaTuple>(&self, input: &T) -> Self::Out;

    fn join(self, other: impl CardComponent2) -> impl CardComponent2
    where
        Self: Sized,
    {
        Join(self, other)
    }
}

impl<A: CardComponent2, B: CardComponent2> CardComponent2 for Join<A, B> {
    type Out = meta_tuple_type!(#A::Out, #B::Out);
    fn play<T: MetaTuple>(&self, input: &T) -> Self::Out {
        let out = self.0.play(input);
        let out_2 = self.1.play(&input.join_tuple(&out));
        meta_tuple!(#out, #out_2)
    }
}

pub trait Metadata: MetaAny + Any {}

impl<T> Metadata for T where T: MetaAny + Any {}

impl_meta_any!(Metadata);

#[test]
fn metadata() {
    let boxed: Box<dyn Metadata> = Box::new(());
    assert_eq!(boxed.get::<f32>(), None)
}