logify 0.1.0

A high-performance, portable boolean logic engine. Turns abstract logic into optimized data structures that can be serialized, cached, and evaluated against arbitrary user data (Bitmaps, Sets, JSON, etc).
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

use std::fmt::Display;

use logify::{
    ExpressionBuilder, logic,
    opt::{Mergeable, OptimizerConfig, SetRelation},
};

// Geographical locations
#[derive(PartialEq, Hash, Clone, Debug)]
enum Geo {
    USA,
    California,
    Texas,
    France,
    Paris,
}

impl Display for Geo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let loc = match self {
            Geo::USA => "USA",
            Geo::California => "California",
            Geo::Texas => "Texas",
            Geo::France => "France",
            Geo::Paris => "Paris",
        };
        write!(f, "{}", loc)
    }
}

// Define the relationships
struct GeoMerger;

impl Mergeable<Geo> for GeoMerger {
    fn get_relation(&mut self, a: &Geo, b: &Geo) -> SetRelation {
        // mark subset as inside of, and superset as contains
        match (a, b) {
            (Geo::California, Geo::USA) => SetRelation::Subset,
            (Geo::Texas, Geo::USA) => SetRelation::Subset,
            (Geo::Paris, Geo::France) => SetRelation::Subset,

            (Geo::USA, Geo::California) => SetRelation::Superset,

            (Geo::Texas, Geo::France) => SetRelation::Disjoint,
            (Geo::France, Geo::Texas) => SetRelation::Disjoint,

            // ... (omitted other cases and inverses for brevity)
            _ => SetRelation::Trivial,
        }
    }
}

fn main() {
    let mut config = OptimizerConfig {
        merger: GeoMerger,
        merger_depth: 2,
        max_iterations: 0,
    };

    // Example 1. California is inside of USA, so it will be redacted
    {
        let builder = ExpressionBuilder::new();
        let rule = logic!(
            builder,
            any![{ Geo::California }, { Geo::USA }, { Geo::Paris }]
        );
        builder.add_root(rule);

        let mut expr = builder.build();

        let root = expr.roots().next().unwrap();
        println!("1. Before: {}", expr.to_string(root));

        expr.optimize(&mut config);

        let new_root = expr.roots().next().unwrap();
        println!("1. After:  {}", expr.to_string(new_root));
    }
    println!();

    // Example 2. Texas and France are disjoint, so the result is EMPTY
    {
        let builder = ExpressionBuilder::new();
        let rule = logic!(builder, all![{ Geo::Texas }, { Geo::France }]);
        builder.add_root(rule);

        let mut expr = builder.build();

        let root = expr.roots().next().unwrap();
        println!("2. Before: {}", expr.to_string(root));

        expr.optimize(&mut config);

        let new_root = expr.roots().next().unwrap();
        println!("2. After:  {}", expr.to_string(new_root));
    }
    println!();

    // Example 3. California and Texas are both within the USA, so USA is redundant
    {
        let builder = ExpressionBuilder::new();
        let rule = logic!(
            builder,
            all![any![{ Geo::California }, { Geo::Texas }], { Geo::USA }]
        );
        builder.add_root(rule);

        let mut expr = builder.build();

        let root = expr.roots().next().unwrap();
        println!("3. Before: {}", expr.to_string(root));

        expr.optimize(&mut config);

        let new_root = expr.roots().next().unwrap();
        println!("3. After:  {}", expr.to_string(new_root));
    }
}