bool-logic 0.3.3

A library for manipulating and evaluating boolean expressions
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
122

use std::slice;

use crate::ast::{All, Any, Expr, Not};
use crate::utils::remove_if;
use crate::visit_mut::VisitMut;
use crate::visit_mut::walk_mut_expr_list;

pub struct SimplifyAllNotAny;

impl<T> VisitMut<T> for SimplifyAllNotAny
where
    T: Eq,
{
    /// `all(not(any(x0, x1, ...)), any(x0, x2, ...)) => all(not(any(...)), any(x0, ...))`
    fn visit_mut_all(&mut self, All(all): &mut All<T>) {
        walk_mut_expr_list(self, all);

        match all.as_mut_slice() {
            [Expr::Any(Any(pos)), Expr::Not(Not(not))]
            | [Expr::Not(Not(not)), Expr::Any(Any(pos))] => {
                let neg = match not.as_mut_any() {
                    Some(Any(neg)) => neg,
                    None => slice::from_mut(&mut **not),
                };
                remove_if(pos, |x| neg.contains(x));
            }
            _ => {}
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::ast::{all, any, expr, not, var};

    #[test]
    fn simplify_all_not_any_basic() {
        let mut x = expr(all((not(any((var(1), var(2)))), any((var(1), var(3))))));
        let expected = expr(all((not(any((var(1), var(2)))), any((var(3),)))));

        SimplifyAllNotAny.visit_mut_expr(&mut x);

        assert_eq!(x.to_string(), expected.to_string());
    }

    #[test]
    fn simplify_all_not_any_reverse_order() {
        let mut x = expr(all((any((var(1), var(3))), not(any((var(1), var(2)))))));
        let expected = expr(all((any((var(3),)), not(any((var(1), var(2)))))));

        SimplifyAllNotAny.visit_mut_expr(&mut x);

        assert_eq!(x.to_string(), expected.to_string());
    }

    #[test]
    fn simplify_all_not_any_complete_overlap() {
        let mut x = expr(all((not(any((var(1), var(2)))), any((var(1), var(2))))));
        let expected = expr(all((not(any((var(1), var(2)))), any(()))));

        SimplifyAllNotAny.visit_mut_expr(&mut x);

        assert_eq!(x.to_string(), expected.to_string());
    }

    #[test]
    fn simplify_all_not_any_no_overlap() {
        let mut x = expr(all((not(any((var(1), var(2)))), any((var(3), var(4))))));
        let expected = expr(all((not(any((var(1), var(2)))), any((var(3), var(4))))));

        SimplifyAllNotAny.visit_mut_expr(&mut x);

        assert_eq!(x.to_string(), expected.to_string());
    }

    #[test]
    fn simplify_all_not_expr_direct() {
        let mut x = expr(all((not(var(1)), any((var(1), var(2))))));
        let expected = expr(all((not(var(1)), any((var(2),)))));

        SimplifyAllNotAny.visit_mut_expr(&mut x);

        assert_eq!(x.to_string(), expected.to_string());
    }

    #[test]
    fn no_simplify_wrong_pattern() {
        let mut x = expr(all((var(1), var(2), var(3))));
        let expected = expr(all((var(1), var(2), var(3))));

        SimplifyAllNotAny.visit_mut_expr(&mut x);

        assert_eq!(x.to_string(), expected.to_string());
    }

    #[test]
    fn no_simplify_single_expr() {
        let mut x = expr(all((not(any((var(1), var(2)))),)));
        let expected = expr(all((not(any((var(1), var(2)))),)));

        SimplifyAllNotAny.visit_mut_expr(&mut x);

        assert_eq!(x.to_string(), expected.to_string());
    }

    #[test]
    fn simplify_partial_overlap() {
        let mut x = expr(all((
            not(any((var(1), var(2), var(3)))),
            any((var(1), var(4), var(5))),
        )));
        let expected = expr(all((
            not(any((var(1), var(2), var(3)))),
            any((var(4), var(5))),
        )));

        SimplifyAllNotAny.visit_mut_expr(&mut x);

        assert_eq!(x.to_string(), expected.to_string());
    }
}