finit 0.4.0

Finit is a library for defining sets of data, and then performing set operations on them. It is designed to be used for permission systems, but can be used for any kind of data that can be represented as a set.
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use crate::Set;
use crate::operations::{
    Difference, DifferenceAssign, DisjunctiveUnion, DisjunctiveUnionAssign, Intersection,
    IntersectionAssign, Union, UnionAssign,
};
use crate::comparisons::{SetEq, SubsetOf};

impl<Value: Set> Set for Box<Value> {
    type Empty = Box<Value::Empty>;

    fn is_empty(&self) -> bool {
        self.as_ref().is_empty()
    }

    fn empty() -> Self::Empty {
        Box::new(Value::empty())
    }
}

// Option A <-> Option B implementations
impl<Value, OtherValue> UnionAssign<OtherValue> for Box<Value>
where
    Value: UnionAssign<OtherValue>,
{
    fn union_assign(&mut self, other: OtherValue) {
        self.as_mut().union_assign(other);
    }
}

impl<Value, OtherValue> DifferenceAssign<OtherValue> for Box<Value>
where
    Value: DifferenceAssign<OtherValue>,
{
    fn difference_assign(&mut self, other: OtherValue) {
        self.as_mut().difference_assign(other);
    }
}

impl<Value, OtherValue> IntersectionAssign<OtherValue> for Box<Value>
where
    Value: IntersectionAssign<OtherValue>,
{
    fn intersection_assign(&mut self, other: OtherValue) {
        self.as_mut().intersection_assign(other);
    }
}

impl<Value, OtherValue> DisjunctiveUnionAssign<OtherValue> for Box<Value>
where
    Value: DisjunctiveUnionAssign<OtherValue>,
{
    fn disjunctive_union_assign(&mut self, other: OtherValue) {
        self.as_mut().disjunctive_union_assign(other);
    }
}

impl<Value, OtherValue> Union<OtherValue> for Box<Value>
where
    Value: Union<OtherValue>,
{
    type Output = Box<Value::Output>;

    fn union(self, rhs: OtherValue) -> Self::Output {
        Box::new((*self).union(rhs))
    }
}

impl<Value, OtherValue> Difference<OtherValue> for Box<Value>
where
    Value: Difference<OtherValue>,
{
    type Output = Box<Value::Output>;

    fn difference(self, rhs: OtherValue) -> Self::Output {
        Box::new((*self).difference(rhs))
    }
}

impl<Value, OtherValue> Intersection<OtherValue> for Box<Value>
where
    Value: Intersection<OtherValue>,
{
    type Output = Box<Value::Output>;

    fn intersection(self, rhs: OtherValue) -> Self::Output {
        Box::new((*self).intersection(rhs))
    }
}

impl<Value, OtherValue> DisjunctiveUnion<OtherValue> for Box<Value>
where
    Value: DisjunctiveUnion<OtherValue>,
{
    type Output = Box<Value::Output>;

    fn disjunctive_union(self, rhs: OtherValue) -> Self::Output {
        Box::new((*self).disjunctive_union(rhs))
    }
}

impl<Value, OtherValue> SetEq<OtherValue> for Box<Value>
where
    Value: SetEq<OtherValue>,
{
    fn set_eq(&self, rhs: &OtherValue) -> bool {
        Value::set_eq(&**self, rhs)
    }
}

impl<Value, OtherValue> SubsetOf<OtherValue> for Box<Value>
where
    Value: SubsetOf<OtherValue>,
{
    fn subset_of(&self, rhs: &OtherValue) -> bool {
        Value::subset_of(&**self, rhs)
    }
}