hemoglobin 0.13.0

Utilities for Bloodless
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
118
119
120
121

use super::{Comparison, ImpreciseEq, MaybeImprecise, MaybeVar};

impl ImpreciseEq<Self> for Comparison {
    fn imprecise_eq(&self, other: &Self) -> bool {
        match (self, other) {
            (
                Self::Equal(x),
                Self::Equal(y) | Self::GreaterThanOrEqual(y) | Self::LowerThanOrEqual(y),
            ) => x == y,
            (Self::GreaterThan(x), Self::GreaterThan(y) | Self::Equal(y) | Self::NotEqual(y)) => {
                x > y
            }
            (
                Self::GreaterThanOrEqual(x),
                Self::GreaterThanOrEqual(y)
                | Self::LowerThanOrEqual(y)
                | Self::GreaterThan(y)
                | Self::Equal(y),
            ) => x >= y,
            (Self::LowerThan(x), Self::LowerThan(y) | Self::Equal(y) | Self::NotEqual(y)) => x < y,
            (
                Self::LowerThanOrEqual(x),
                Self::LowerThanOrEqual(y)
                | Self::GreaterThanOrEqual(y)
                | Self::LowerThan(y)
                | Self::Equal(y),
            ) => x <= y,
            (Self::NotEqual(_), Self::Equal(_)) => false,
            (Self::NotEqual(_), _) => true,
            _ => false,
        }
    }
}

impl ImpreciseEq<usize> for Comparison {
    fn imprecise_eq(&self, other: &usize) -> bool {
        self.compare(other).into()
    }
}

// Reverse
impl ImpreciseEq<Comparison> for usize {
    fn imprecise_eq(&self, other: &Comparison) -> bool {
        other.imprecise_eq(self)
    }
}

impl ImpreciseEq<Self> for MaybeVar {
    fn imprecise_eq(&self, other: &Self) -> bool {
        self.assume() == other.assume()
    }
}

impl ImpreciseEq<usize> for MaybeVar {
    fn imprecise_eq(&self, other: &usize) -> bool {
        self.assume() == *other
    }
}

// Reverse
impl ImpreciseEq<MaybeVar> for usize {
    fn imprecise_eq(&self, other: &MaybeVar) -> bool {
        other.imprecise_eq(self)
    }
}

impl ImpreciseEq<MaybeVar> for Comparison {
    fn imprecise_eq(&self, other: &MaybeVar) -> bool {
        self.compare(&other.assume()).into()
    }
}

// Reverse
impl ImpreciseEq<Comparison> for MaybeVar {
    fn imprecise_eq(&self, other: &Comparison) -> bool {
        other.imprecise_eq(self)
    }
}

impl ImpreciseEq<Self> for MaybeImprecise {
    fn imprecise_eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::Precise(x), Self::Imprecise(y)) | (Self::Imprecise(y), Self::Precise(x)) => {
                x.imprecise_eq(y)
            }
            (Self::Precise(x), Self::Precise(y)) => x.imprecise_eq(y),
            (Self::Imprecise(x), Self::Imprecise(y)) => x.imprecise_eq(y),
        }
    }
}

impl ImpreciseEq<usize> for MaybeImprecise {
    fn imprecise_eq(&self, other: &usize) -> bool {
        match self {
            Self::Precise(x) => x.imprecise_eq(other),
            Self::Imprecise(x) => x.imprecise_eq(other),
        }
    }
}

// Reverse
impl ImpreciseEq<MaybeImprecise> for usize {
    fn imprecise_eq(&self, other: &MaybeImprecise) -> bool {
        other.imprecise_eq(self)
    }
}
impl ImpreciseEq<MaybeVar> for MaybeImprecise {
    fn imprecise_eq(&self, other: &MaybeVar) -> bool {
        match self {
            Self::Precise(x) => x.imprecise_eq(other),
            Self::Imprecise(x) => x.imprecise_eq(other),
        }
    }
}

// Reverse
impl ImpreciseEq<MaybeImprecise> for MaybeVar {
    fn imprecise_eq(&self, other: &MaybeImprecise) -> bool {
        other.imprecise_eq(self)
    }
}