datalogic-rs 4.0.21

A fast, type-safe Rust implementation of JSONLogic for evaluating logical rules as JSON. Perfect for business rules engines and dynamic filtering in Rust applications.
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

//! Strength reduction pass.
//!
//! Replaces expensive patterns with cheaper equivalents:
//! - `{"!": [{"!": [X]}]}` → `{"!!": [X]}` (double negation → bool coerce)
//! - `{"!!": [{"!!": [X]}]}` → `{"!!": [X]}` (idempotent bool coerce)

use crate::node::CompiledNode;
use crate::opcode::OpCode;

/// Apply strength reduction to a compiled node.
pub fn reduce(node: CompiledNode) -> CompiledNode {
    match &node {
        CompiledNode::BuiltinOperator { opcode, args } => {
            match opcode {
                OpCode::Not if args.len() == 1 => {
                    // Check if inner is also Not → collapse to DoubleNot
                    if let CompiledNode::BuiltinOperator {
                        opcode: OpCode::Not,
                        args: inner_args,
                    } = &args[0]
                        && inner_args.len() == 1
                    {
                        return CompiledNode::BuiltinOperator {
                            opcode: OpCode::DoubleNot,
                            args: inner_args.clone(),
                        };
                    }
                    node
                }
                OpCode::DoubleNot if args.len() == 1 => {
                    // Check if inner is also DoubleNot → collapse (idempotent)
                    if let CompiledNode::BuiltinOperator {
                        opcode: OpCode::DoubleNot,
                        args: inner_args,
                    } = &args[0]
                        && inner_args.len() == 1
                    {
                        return CompiledNode::BuiltinOperator {
                            opcode: OpCode::DoubleNot,
                            args: inner_args.clone(),
                        };
                    }
                    node
                }
                _ => node,
            }
        }
        _ => node,
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn var_node(name: &str) -> CompiledNode {
        CompiledNode::CompiledVar {
            scope_level: 0,
            segments: vec![crate::node::PathSegment::Field(name.into())].into_boxed_slice(),
            reduce_hint: crate::node::ReduceHint::None,
            metadata_hint: crate::node::MetadataHint::None,
            default_value: None,
        }
    }

    fn builtin(opcode: OpCode, args: Vec<CompiledNode>) -> CompiledNode {
        CompiledNode::BuiltinOperator {
            opcode,
            args: args.into_boxed_slice(),
        }
    }

    #[test]
    fn test_double_negation() {
        let inner = builtin(OpCode::Not, vec![var_node("x")]);
        let outer = builtin(OpCode::Not, vec![inner]);
        let result = reduce(outer);
        if let CompiledNode::BuiltinOperator { opcode, args } = &result {
            assert_eq!(*opcode, OpCode::DoubleNot);
            assert_eq!(args.len(), 1);
        } else {
            panic!("expected BuiltinOperator");
        }
    }

    #[test]
    fn test_idempotent_double_not() {
        let inner = builtin(OpCode::DoubleNot, vec![var_node("x")]);
        let outer = builtin(OpCode::DoubleNot, vec![inner]);
        let result = reduce(outer);
        if let CompiledNode::BuiltinOperator { opcode, args } = &result {
            assert_eq!(*opcode, OpCode::DoubleNot);
            assert_eq!(args.len(), 1);
            assert!(matches!(&args[0], CompiledNode::CompiledVar { .. }));
        } else {
            panic!("expected BuiltinOperator");
        }
    }
}