cons_cell 0.1.0

Swiss knife for heterogenous containers
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use crate::cons::traits::switches::contains_switch::ContainsSwitch;
use crate::cons::{Cons, ConsCell, Nil};
use typenum::{Bit, False, True};
use typenum_uuid_trait::TypeId;

pub trait ContainsAnySwitch<Contained: ConsCell> {
    type Value: Bit;
}

pub trait ContainsAnySwitchHelper<Tail: ConsCell, HeadContained: Bit>
where
    Self: ContainsAnySwitch<Tail>,
{
    type Value: Bit;
}

impl<Contained: Cons, Container: ConsCell> ContainsAnySwitch<Contained> for Container
where
    Contained::Head: TypeId,
    Container: ContainsSwitch<Contained::Head>,
    Container: ContainsAnySwitch<Contained::Tail>,
    Container: ContainsAnySwitchHelper<
            Contained::Tail,
            <Container as ContainsSwitch<Contained::Head>>::Value,
        >,
{
    type Value = <Container as ContainsAnySwitchHelper<
        Contained::Tail,
        <Container as ContainsSwitch<Contained::Head>>::Value,
    >>::Value;
}

impl<Tail: ConsCell, C: ConsCell> ContainsAnySwitchHelper<Tail, True> for C
where
    Self: ContainsAnySwitch<Tail>,
{
    type Value = <C as ContainsAnySwitch<Tail>>::Value;
}

impl<Tail: ConsCell, C: ConsCell> ContainsAnySwitchHelper<Tail, False> for C
where
    Self: ContainsAnySwitch<Tail>,
{
    type Value = False;
}

impl<NilSeed, Container: ConsCell> ContainsAnySwitch<Nil<NilSeed>> for Container {
    type Value = True;
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::cons::ConsCell;
    use crate::cons::test_types::*;
    use crate::cons::types::hcons::{HCons, HNil};

    pub trait ContainsManyTest<Contained: ConsCell>: Cons {}

    impl<Container: Cons + ContainsAnySwitch<Contained, Value = True>, Contained: ConsCell>
        ContainsManyTest<Contained> for Container
    {
    }

    fn only_contains_many<Contained: ConsCell, C: ContainsManyTest<Contained>>(_: &C) {}

    #[test]
    fn contains_many() {
        let c = HNil::new().extend(U8(1)).extend(U32(2)).extend(U64(3));
        only_contains_many::<HCons<U8, HCons<U64, HNil>>, _>(&c);

        // Does not compile
        //only_contains_many::<HCons<U16, HCons<U8, HNil>>, _>(&c);
    }

    pub trait DoesNotContainManyTest<Contained: ConsCell>: Cons {}

    impl<Container: Cons + ContainsAnySwitch<Contained, Value = False>, Contained: ConsCell>
        DoesNotContainManyTest<Contained> for Container
    {
    }

    fn only_does_not_contain_many<Contained: ConsCell, C: DoesNotContainManyTest<Contained>>(
        _: &C,
    ) {
    }

    #[test]
    fn does_not_contain_many() {
        let c = HNil::new().extend(U8(1)).extend(U32(2)).extend(U64(3));
        only_does_not_contain_many::<HCons<U16, HCons<U8, HNil>>, _>(&c);

        // Does not compile
        //only_does_not_contain_many::<HCons<U8, HCons<U64, HNil>>, _>(&c);
    }
}