Module rule_executor 

Rule execution for backward chaining

This module provides proper condition evaluation and action execution for backward chaining queries. It integrates with the Truth Maintenance System (TMS) to support logical fact insertion and justification-based retraction.

Features

• Condition evaluation - Evaluate rule conditions against current facts
• Action execution - Execute rule actions (Set, MethodCall, Log, Retract)
• TMS integration - Optional logical fact insertion with justifications
• Function support - Built-in functions (len, isEmpty, exists, etc.)
• Type conversion - Convert between Facts (string-based) and TypedFacts (RETE)

Architecture

┌──────────────────┐
│  RuleExecutor    │
│                  │
│  ┌────────────┐  │
│  │ Condition  │──┼──> ConditionEvaluator
│  │ Evaluator  │  │       │
│  └────────────┘  │       ├─> Built-in functions
│                  │       └─> Field comparison
│  ┌────────────┐  │
│  │   Action   │──┼──> Set, MethodCall, Log
│  │ Executor   │  │       │
│  └────────────┘  │       └─> TMS Inserter (optional)
└──────────────────┘

Example: Basic Rule Execution

use rust_rule_engine::backward::rule_executor::RuleExecutor;
use rust_rule_engine::engine::rule::{Rule, Condition, ConditionGroup};
use rust_rule_engine::types::{Operator, ActionType, Value};
use rust_rule_engine::{KnowledgeBase, Facts};

let kb = KnowledgeBase::new("test");
let executor = RuleExecutor::new(kb);

// Define a rule: If User.Age > 18, then User.IsAdult = true
let conditions = ConditionGroup::Single(
    Condition::new(
        "User.Age".to_string(),
        Operator::GreaterThan,
        Value::Number(18.0),
    )
);
let actions = vec![ActionType::Set {
    field: "User.IsAdult".to_string(),
    value: Value::Boolean(true),
}];
let rule = Rule::new("CheckAdult".to_string(), conditions, actions);

// Execute rule
let mut facts = Facts::new();
facts.set("User.Age", Value::Number(25.0));

let executed = executor.try_execute_rule(&rule, &mut facts)?;
assert!(executed); // Rule should execute successfully
assert_eq!(facts.get("User.IsAdult"), Some(Value::Boolean(true)));

Example: TMS Integration

use rust_rule_engine::backward::rule_executor::RuleExecutor;
use rust_rule_engine::rete::propagation::IncrementalEngine;
use rust_rule_engine::{KnowledgeBase, Facts};
use std::sync::{Arc, Mutex};

let kb = KnowledgeBase::new("test");
let rete_engine = Arc::new(Mutex::new(IncrementalEngine::new()));

// Create TMS inserter callback
let inserter = {
    let eng = rete_engine.clone();
    Arc::new(move |fact_type: String, data, rule_name: String, premises: Vec<String>| {
        if let Ok(mut e) = eng.lock() {
            let handles = e.resolve_premise_keys(premises);
            let _ = e.insert_logical(fact_type, data, rule_name, handles);
        }
    })
};

let executor = RuleExecutor::new_with_inserter(kb, Some(inserter));
// Now rule executions will insert facts logically with justifications

Supported Action Types

• Set - Set a fact value: field: value
• MethodCall - Call a method on an object: object.method(args)
• Log - Log a message: log("message")
• Retract - Retract a fact: retract(field)

Built-in Functions

The executor supports these built-in functions for condition evaluation:

• len(field) - Get string/array length
• isEmpty(field) - Check if string/array is empty
• exists(field) - Check if field exists
• count(field) - Count array elements

Structs

RuleExecutor

Rule executor for backward chaining