datalogic-rs 5.0.0

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

//! Execution tracing — see every step the engine takes.
//!
//! `engine.trace().eval_str(...)` returns a `TracedRun` whose
//! `steps` field logs each evaluated node along with its result (or
//! error). Use it to debug rules that return something unexpected.
//!
//! Run:
//!
//!     cargo run --example tracing --features trace

use datalogic_rs::Engine;

fn main() {
    let engine = Engine::new();

    // ----- (1) success -----------------------------------------------
    let run = engine.trace().eval_str(
        r#"{"if": [{">": [{"var": "age"}, 18]}, "adult", "minor"]}"#,
        r#"{"age": 21}"#,
    );

    println!("[1] result: {}", run.result.as_ref().unwrap());
    println!("    steps:  {}", run.steps.len());
    for step in &run.steps {
        let r = step
            .result
            .as_ref()
            .map(|v| v.to_string())
            .unwrap_or_else(|| "<error>".into());
        println!("    #{}  node {} -> {}", step.step_id, step.node_id, r);
    }

    // ----- (2) failure — error is structured ------------------------
    let run = engine
        .trace()
        .eval_str(r#"{"+": [{"var": "x"}, "not-a-number"]}"#, r#"{"x": 1}"#);

    let err = run.result.unwrap_err();
    println!("\n[2] failure");
    println!("    tag: {}", err.tag());
    println!("    operator: {:?}", err.operator());
    println!("    steps:    {} recorded before failure", run.steps.len());
}