type-sets 0.2.3

Sets implemented in the rust type-system
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

use type_sets::{
    assert::{contains, eq, is_empty, subset, superset},
    *,
};

struct A;
struct B;
struct C;
struct D;
struct E;

#[test]
fn test() {
    superset::<(A,), (A,)>();
    superset::<(A, B), (A,)>();
    superset::<(B, A, C), (A,)>();
    // superset::<(E, B, C), (A,)>();

    contains::<(A,), A>();
    contains::<(A, B), A>();
    contains::<(B, A, C), A>();
    // contains::<(E, B, C), A>();

    subset::<(A, B), (A, B)>();
    subset::<(A,), (A,)>();
    subset::<(B, A, C), (A, B, C)>();
    // subset::<(E, B, C), (A, B, C)>();

    type X = Insert<(), A>;
    type Y = Insert<X, B>;
    type Z = Insert<Y, C>;

    eq::<X, (A,)>();
    eq::<Y, (B, A)>();
    eq::<Z, (A, B, C)>();

    // eq::<Pop<Z>, (A, B)>();
    // eq::<Pop<Y>, (A,)>();
    // eq::<Pop<X>, ()>();

    // eq::<(Last<Z>,), (C,)>();
    // eq::<(Last<Y>,), (B,)>();
    // eq::<(Last<X>,), (A,)>();

    eq::<Union<Z, (D,)>, (A, B, C, D)>();
    eq::<Union<Z, (D, E)>, (A, B, C, D, E)>();
    eq::<Union<Z, (D, E, A)>, (A, B, C, D, E, A)>();
    eq::<Union<Z, (D, E, A)>, (A, B, C, D, E, A)>();

    is_empty::<()>();
    is_empty::<Union<(), ()>>();
}

fn subset_of_any<T: AsTypeSet>() {
    subset::<(), T>()
}

// Regression test: `Members::members()` used to cache its result in a
// function-local `static`, which is shared across every monomorphization of
// a generic function. That meant the first same-arity tuple queried in the
// process would "win" the cache, and every other same-arity tuple would
// silently get its `TypeId`s instead.
#[test]
fn members_are_distinct_per_type() {
    use std::any::TypeId;

    let a1 = <(A,) as Members>::members();
    let b1 = <(B,) as Members>::members();
    assert_eq!(a1, &[TypeId::of::<A>()]);
    assert_eq!(b1, &[TypeId::of::<B>()]);

    let ab2 = <(A, B) as Members>::members();
    let cd2 = <(C, D) as Members>::members();
    assert_eq!(ab2, &[TypeId::of::<A>(), TypeId::of::<B>()]);
    assert_eq!(cd2, &[TypeId::of::<C>(), TypeId::of::<D>()]);
}