Struct KnowledgeBase 

pub struct KnowledgeBase { /* private fields */ }

Knowledge Base - manages collections of rules and facts Similar to Grule’s KnowledgeBase concept

Implementations

impl KnowledgeBase

pub fn new(name: &str) -> Self

Create a new knowledge base

Examples found in repository

examples/grule_demo.rs (line 32)

fn demo_knowledge_base() -> std::result::Result<(), Box<dyn std::error::Error>> {
    println!("📚 Demo 1: Knowledge Base with Code-based Rules");
    println!("-----------------------------------------------");

    // Create knowledge base
    let kb = KnowledgeBase::new("UserRules");

    println!("✅ Knowledge Base created: {}", kb.get_statistics().name);
    println!("   Total rules: {}", kb.get_statistics().total_rules);
    println!("   Version: {}\n", kb.get_statistics().version);

    Ok(())
}

fn demo_facts_manipulation() -> std::result::Result<(), Box<dyn std::error::Error>> {
    println!("🗂️ Demo 2: Facts Manipulation");
    println!("-----------------------------");

    // Create facts
    let facts = Facts::new();

    // Add user data
    let mut user_props = HashMap::new();
    user_props.insert("Name".to_string(), Value::String("John Doe".to_string()));
    user_props.insert("Age".to_string(), Value::Integer(25));
    user_props.insert("Country".to_string(), Value::String("US".to_string()));
    user_props.insert("SpendingTotal".to_string(), Value::Number(1500.0));
    user_props.insert("IsAdult".to_string(), Value::Boolean(false));
    user_props.insert("IsVIP".to_string(), Value::Boolean(false));

    facts.add_value("User", Value::Object(user_props))?;

    println!("✅ Facts created and populated:");
    if let Some(user) = facts.get("User") {
        println!("   User = {user:?}");
    }
    println!();

    Ok(())
}

fn demo_engine_execution() -> std::result::Result<(), Box<dyn std::error::Error>> {
    println!("🚀 Demo 3: Engine Execution");
    println!("---------------------------");

    // Create facts
    let facts = Facts::new();
    let mut user_props = HashMap::new();
    user_props.insert("Age".to_string(), Value::Integer(25));
    user_props.insert("Country".to_string(), Value::String("US".to_string()));
    user_props.insert("SpendingTotal".to_string(), Value::Number(1500.0));
    user_props.insert("IsAdult".to_string(), Value::Boolean(false));
    user_props.insert("IsVIP".to_string(), Value::Boolean(false));
    user_props.insert("Category".to_string(), Value::String("unknown".to_string()));
    user_props.insert("DiscountRate".to_string(), Value::Number(0.0));

    facts.add_value("User", Value::Object(user_props))?;

    // Create knowledge base
    let mut kb = KnowledgeBase::new("UserRules");

    // Rule 1: Adult Check (salience 10)
    let adult_rule = Rule::new(
        "AdultCheck".to_string(),
        ConditionGroup::and(
            ConditionGroup::single(Condition::new(
                "User.Age".to_string(),
                Operator::GreaterThanOrEqual,
                Value::Integer(18),
            )),
            ConditionGroup::single(Condition::new(
                "User.Country".to_string(),
                Operator::Equal,
                Value::String("US".to_string()),
            )),
        ),
        vec![
            ActionType::MethodCall {
                object: "User".to_string(),
                method: "setIsAdult".to_string(),
                args: vec![Value::Boolean(true)],
            },
            ActionType::MethodCall {
                object: "User".to_string(),
                method: "setCategory".to_string(),
                args: vec![Value::String("Adult".to_string())],
            },
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String("User qualified as adult".to_string())],
            },
        ],
    )
    .with_salience(10);

    // Rule 2: VIP Check (salience 20)
    let vip_rule = Rule::new(
        "VIPCheck".to_string(),
        ConditionGroup::and(
            ConditionGroup::and(
                ConditionGroup::single(Condition::new(
                    "User.Age".to_string(),
                    Operator::GreaterThanOrEqual,
                    Value::Integer(21),
                )),
                ConditionGroup::single(Condition::new(
                    "User.IsAdult".to_string(),
                    Operator::Equal,
                    Value::Boolean(true),
                )),
            ),
            ConditionGroup::single(Condition::new(
                "User.SpendingTotal".to_string(),
                Operator::GreaterThan,
                Value::Number(1000.0),
            )),
        ),
        vec![
            ActionType::MethodCall {
                object: "User".to_string(),
                method: "setIsVIP".to_string(),
                args: vec![Value::Boolean(true)],
            },
            ActionType::MethodCall {
                object: "User".to_string(),
                method: "setDiscountRate".to_string(),
                args: vec![Value::Number(0.15)],
            },
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String("User upgraded to VIP".to_string())],
            },
        ],
    )
    .with_salience(20);

    // Rule 3: Senior Discount (salience 15)
    let senior_rule = Rule::new(
        "SeniorDiscount".to_string(),
        ConditionGroup::single(Condition::new(
            "User.Age".to_string(),
            Operator::GreaterThanOrEqual,
            Value::Integer(65),
        )),
        vec![
            ActionType::MethodCall {
                object: "User".to_string(),
                method: "setDiscountRate".to_string(),
                args: vec![Value::Number(0.20)],
            },
            ActionType::MethodCall {
                object: "User".to_string(),
                method: "setCategory".to_string(),
                args: vec![Value::String("Senior".to_string())],
            },
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String("Senior discount applied".to_string())],
            },
        ],
    )
    .with_salience(15);

    // Add rules to knowledge base
    let _ = kb.add_rule(adult_rule);
    let _ = kb.add_rule(vip_rule);
    let _ = kb.add_rule(senior_rule);

    // Create engine
    let config = EngineConfig {
        debug_mode: true,
        max_cycles: 3,
        ..Default::default()
    };
    let engine = RustRuleEngine::with_config(kb, config);

    println!("🏁 Initial state:");
    if let Some(user) = facts.get("User") {
        println!("   User = {user:?}");
    }
    println!();

    // Execute rules
    println!("🚀 Executing rules...");
    let result = engine.execute(&facts)?;

    println!("\n📊 Execution Results:");
    println!("   Cycles: {}", result.cycle_count);
    println!("   Rules evaluated: {}", result.rules_evaluated);
    println!("   Rules fired: {}", result.rules_fired);
    println!("   Execution time: {:?}", result.execution_time);

    println!("\n🏁 Final state:");
    if let Some(user) = facts.get("User") {
        println!("   User = {user:?}");
    }
    println!();

    Ok(())
}

fn demo_ecommerce_scenario() -> std::result::Result<(), Box<dyn std::error::Error>> {
    println!("🛒 Demo 4: E-commerce Scenario");
    println!("------------------------------");

    // Create facts
    let facts = Facts::new();

    // Customer data
    let mut customer_props = HashMap::new();
    customer_props.insert(
        "Email".to_string(),
        Value::String("customer@example.com".to_string()),
    );
    customer_props.insert("Age".to_string(), Value::Integer(28));
    customer_props.insert("IsNew".to_string(), Value::Boolean(true));
    customer_props.insert("LoyaltyPoints".to_string(), Value::Integer(0));
    customer_props.insert("TotalSpent".to_string(), Value::Number(0.0));

    // Order data
    let mut order_props = HashMap::new();
    order_props.insert("Id".to_string(), Value::String("ORD-12345".to_string()));
    order_props.insert("Amount".to_string(), Value::Number(150.0));
    order_props.insert(
        "Category".to_string(),
        Value::String("electronics".to_string()),
    );
    order_props.insert("DiscountPercent".to_string(), Value::Number(0.0));
    order_props.insert("FinalAmount".to_string(), Value::Number(150.0));

    facts.add_value("Customer", Value::Object(customer_props))?;
    facts.add_value("Order", Value::Object(order_props))?;

    // Create knowledge base
    let mut kb = KnowledgeBase::new("EcommerceRules");

    // Rule 1: New Customer Discount
    let new_customer_rule = Rule::new(
        "NewCustomerDiscount".to_string(),
        ConditionGroup::and(
            ConditionGroup::single(Condition::new(
                "Customer.IsNew".to_string(),
                Operator::Equal,
                Value::Boolean(true),
            )),
            ConditionGroup::single(Condition::new(
                "Order.Amount".to_string(),
                Operator::GreaterThan,
                Value::Number(100.0),
            )),
        ),
        vec![
            ActionType::MethodCall {
                object: "Order".to_string(),
                method: "setDiscountPercent".to_string(),
                args: vec![Value::Number(10.0)],
            },
            ActionType::MethodCall {
                object: "Customer".to_string(),
                method: "setLoyaltyPoints".to_string(),
                args: vec![Value::Integer(100)],
            },
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String("New customer discount applied".to_string())],
            },
        ],
    )
    .with_salience(10);

    // Rule 2: Calculate Final Amount
    let calculate_final_rule = Rule::new(
        "CalculateFinalAmount".to_string(),
        ConditionGroup::single(Condition::new(
            "Order.DiscountPercent".to_string(),
            Operator::GreaterThan,
            Value::Number(0.0),
        )),
        vec![ActionType::Call {
            function: "log".to_string(),
            args: vec![Value::String(
                "Calculating final amount with discount".to_string(),
            )],
        }],
    )
    .with_salience(5);

    // Add rules
    let _ = kb.add_rule(new_customer_rule);
    let _ = kb.add_rule(calculate_final_rule);

    // Create engine
    let config = EngineConfig {
        debug_mode: true,
        max_cycles: 3,
        ..Default::default()
    };
    let engine = RustRuleEngine::with_config(kb, config);

    println!("🏁 Initial e-commerce state:");
    if let Some(customer) = facts.get("Customer") {
        println!("   Customer = {customer:?}");
    }
    if let Some(order) = facts.get("Order") {
        println!("   Order = {order:?}");
    }
    println!();

    // Execute rules
    println!("🚀 Executing e-commerce rules...");
    let result = engine.execute(&facts)?;

    println!("\n📊 E-commerce Results:");
    println!("   Cycles: {}", result.cycle_count);
    println!("   Rules evaluated: {}", result.rules_evaluated);
    println!("   Rules fired: {}", result.rules_fired);
    println!("   Execution time: {:?}", result.execution_time);

    println!("\n🏁 Final e-commerce state:");
    if let Some(customer) = facts.get("Customer") {
        println!("   Customer = {customer:?}");
    }
    if let Some(order) = facts.get("Order") {
        println!("   Order = {order:?}");
    }

    println!("\n🎯 Demo Completed Successfully!");
    println!("   ✅ Knowledge Base management");
    println!("   ✅ Facts manipulation");
    println!("   ✅ Rule execution engine");
    println!("   ✅ E-commerce scenario");
    println!("   ✅ Method calls and function calls");
    println!("   ✅ Salience-based rule ordering");

    Ok(())
}

examples/debug_conditions.rs (line 13)

fn test_simple_conditions() -> std::result::Result<(), Box<dyn Error>> {
    println!("=== Testing Simple Conditions ===");

    // Create Knowledge Base
    let kb = KnowledgeBase::new("TestConditions");

    // Test compound condition with &&
    let compound_rule = r#"rule "CompoundRule" { when TestCar.speedUp == true && TestCar.speed < TestCar.maxSpeed then TestCar.result = "compound_fired"; }"#;

    println!("Testing rule: {}", compound_rule);

    // Parse and add rule
    let rules = GRLParser::parse_rules(compound_rule)?;
    let rule = rules.into_iter().next().unwrap();
    println!("Parsed rule: {:?}", rule);

    let _ = kb.add_rule(rule);

    // Create engine with debug mode
    let config = EngineConfig {
        max_cycles: 10,
        timeout: None,
        enable_stats: true,
        debug_mode: true,
    };
    let engine = RustRuleEngine::with_config(kb, config);

    // Create facts
    let facts = Facts::new();

    // Create simple TestCar object with all needed properties
    let test_car = FactHelper::create_object(vec![
        ("speedUp", Value::Boolean(true)),
        ("speed", Value::Number(30.0)),
        ("maxSpeed", Value::Number(100.0)),
        ("result", Value::String("not_fired".to_string())),
    ]);

    facts.add_value("TestCar", test_car)?;

    println!("\n🏁 Before execution:");
    if let Some(car) = facts.get("TestCar") {
        println!("   TestCar.speedUp = {:?}", car.get_property("speedUp"));
        println!("   TestCar.speed = {:?}", car.get_property("speed"));
        println!("   TestCar.maxSpeed = {:?}", car.get_property("maxSpeed"));
        println!("   TestCar.result = {:?}", car.get_property("result"));
    }

    // Execute rules
    println!("\n🚀 Executing rule...");
    let result = engine.execute(&facts)?;

    println!("Rules fired: {}", result.rules_fired);

    println!("\n🏁 After execution:");
    if let Some(car) = facts.get("TestCar") {
        println!("   TestCar.speedUp = {:?}", car.get_property("speedUp"));
        println!("   TestCar.result = {:?}", car.get_property("result"));
    }

    Ok(())
}

examples/advanced_method_calls.rs (line 13)

fn demo_method_calls() -> std::result::Result<(), Box<dyn Error>> {
    println!("=== Demo: Advanced Method Calls ===");

    // Create Knowledge Base
    let kb = KnowledgeBase::new("MethodCallsDemo");

    // Define rule with simpler condition first
    let speedup_rule = r#"rule "SpeedUp" salience 10 { 
        when TestCar.speedUp == true 
        then TestCar.Speed = 70; 
    }"#;

    // Parse and add rule
    let rules = GRLParser::parse_rules(speedup_rule)?;
    let rule = rules.into_iter().next().unwrap();
    let _ = kb.add_rule(rule);

    // Create engine with debug mode
    let config = EngineConfig {
        max_cycles: 10,
        timeout: None,
        enable_stats: true,
        debug_mode: true,
    };
    let engine = RustRuleEngine::with_config(kb, config);

    // Create facts
    let facts = Facts::new();

    // Create TestCar object using helper
    let test_car = FactHelper::create_test_car(
        true,  // speedUp
        50.0,  // speed
        100.0, // maxSpeed
        10.0,  // speedIncrement
    );

    // Create DistanceRecord object using helper
    let distance_record = FactHelper::create_distance_record(0.0);

    // Add facts
    facts.add_value("TestCar", test_car)?;
    facts.add_value("DistanceRecord", distance_record)?;

    println!("\n🏁 Initial state:");
    if let Some(car) = facts.get("TestCar") {
        if let Some(speed) = car.get_property("Speed") {
            println!("   TestCar.Speed = {:?}", speed);
        }
        if let Some(speed_up) = car.get_property("speedUp") {
            println!("   TestCar.speedUp = {:?}", speed_up);
        }
    }

    // Execute rules multiple cycles to see progression
    println!("\n🚀 Executing SpeedUp rule multiple times...");
    for i in 1..=3 {
        println!("\n--- Cycle {} ---", i);
        let result = engine.execute(&facts)?;

        println!("Rules fired: {}", result.rules_fired);

        if let Some(car) = facts.get("TestCar") {
            if let Some(speed) = car.get_property("Speed") {
                println!("TestCar.Speed after cycle {}: {:?}", i, speed);
            }
        }

        // Check if we reached max speed
        if let Some(car) = facts.get("TestCar") {
            if let Some(speed) = car.get_property("speed") {
                if let Some(max_speed) = car.get_property("maxSpeed") {
                    if speed.to_number() >= max_speed.to_number() {
                        println!("🏁 Max speed reached!");
                        break;
                    }
                }
            }
        }
    }

    println!("\n📊 Final Results:");
    if let Some(car) = facts.get("TestCar") {
        if let Some(speed) = car.get_property("Speed") {
            println!("   Final TestCar.Speed = {:?}", speed);
        }
    }

    Ok(())
}

examples/generic_method_calls.rs (line 37)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Demo: Generic Method Calls ===\n");

    // Create objects with various properties
    let mut car_props = HashMap::new();
    car_props.insert("Speed".to_string(), Value::Number(50.0));
    car_props.insert("Fuel".to_string(), Value::Number(80.0));
    car_props.insert("Brand".to_string(), Value::String("Toyota".to_string()));

    let mut account_props = HashMap::new();
    account_props.insert("Balance".to_string(), Value::Number(1000.0));
    account_props.insert("Owner".to_string(), Value::String("John Doe".to_string()));
    account_props.insert("Active".to_string(), Value::Boolean(true));

    // Create facts
    let facts = Facts::new();
    facts.add_value("Car", Value::Object(car_props))?;
    facts.add_value("Account", Value::Object(account_props))?;

    println!("🏁 Initial state:");
    if let Some(car) = facts.get("Car") {
        println!("   Car = {car:?}");
    }
    if let Some(account) = facts.get("Account") {
        println!("   Account = {account:?}");
    }
    println!();

    // Create knowledge base
    let mut kb = KnowledgeBase::new("GenericMethodDemo");

    // Rule 1: Speed up car if speed < 60
    let speed_rule = Rule::new(
        "SpeedUpCar".to_string(),
        ConditionGroup::single(Condition::new(
            "Car.Speed".to_string(),
            Operator::LessThan,
            Value::Number(60.0),
        )),
        vec![ActionType::MethodCall {
            object: "Car".to_string(),
            method: "setSpeed".to_string(), // Generic setter
            args: vec![Value::Number(75.0)],
        }],
    )
    .with_salience(10);

    // Rule 2: Withdraw from account if balance > 500
    let withdraw_rule = Rule::new(
        "WithdrawMoney".to_string(),
        ConditionGroup::single(Condition::new(
            "Account.Balance".to_string(),
            Operator::GreaterThan,
            Value::Number(500.0),
        )),
        vec![ActionType::MethodCall {
            object: "Account".to_string(),
            method: "setBalance".to_string(), // Generic setter
            args: vec![Value::Number(800.0)],
        }],
    )
    .with_salience(5);

    // Rule 3: Update car brand using generic setter
    let brand_rule = Rule::new(
        "UpdateBrand".to_string(),
        ConditionGroup::single(Condition::new(
            "Car.Brand".to_string(),
            Operator::Equal,
            Value::String("Toyota".to_string()),
        )),
        vec![ActionType::MethodCall {
            object: "Car".to_string(),
            method: "setBrand".to_string(), // Generic setter
            args: vec![Value::String("Honda".to_string())],
        }],
    )
    .with_salience(3);

    // Add rules to knowledge base
    let _ = kb.add_rule(speed_rule);
    let _ = kb.add_rule(withdraw_rule);
    let _ = kb.add_rule(brand_rule);

    // Create engine with debug mode
    let config = EngineConfig {
        debug_mode: true,
        max_cycles: 10,
        ..Default::default()
    };
    let engine = RustRuleEngine::with_config(kb, config);

    // Execute rules
    println!("🚀 Executing rules with generic method calls...");
    let result = engine.execute(&facts)?;

    println!("\n📊 Execution Results:");
    println!("   Cycles: {}", result.cycle_count);
    println!("   Rules evaluated: {}", result.rules_evaluated);
    println!("   Rules fired: {}", result.rules_fired);
    println!("   Execution time: {:?}", result.execution_time);

    println!("\n🏁 Final state:");
    if let Some(car) = facts.get("Car") {
        println!("   Car = {car:?}");
    }
    if let Some(account) = facts.get("Account") {
        println!("   Account = {account:?}");
    }

    // Demonstrate generic getters
    println!("\n🔍 Testing generic getters:");
    if let Some(car_value) = facts.get("Car") {
        if let Value::Object(car_obj) = car_value {
            println!(
                "   Car.Speed via getter would return: {:?}",
                car_obj.get("Speed")
            );
            println!(
                "   Car.Brand via getter would return: {:?}",
                car_obj.get("Brand")
            );
            println!(
                "   Car.Fuel via getter would return: {:?}",
                car_obj.get("Fuel")
            );
        }
    }

    Ok(())
}

examples/method_calls_demo.rs (line 44)

fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    println!("🎯 Method Calls Demo with Rule File");
    println!("===================================\n");

    // Read rules from file
    let rule_file_path = "examples/rules/method_calls.grl";
    println!("📄 Reading rules from file: {}", rule_file_path);

    let rule_content = fs::read_to_string(rule_file_path)
        .map_err(|e| format!("Failed to read rule file: {}", e))?;

    println!("📋 Rule file content:");
    println!("---");
    println!("{}", rule_content);
    println!("---\n");

    // Create facts
    let facts = Facts::new();

    // TestCar data
    let mut test_car_props = HashMap::new();
    test_car_props.insert("Speed".to_string(), Value::Number(30.0));
    test_car_props.insert("MaxSpeed".to_string(), Value::Number(100.0));
    test_car_props.insert("SpeedIncrement".to_string(), Value::Number(10.0));
    test_car_props.insert("SpeedUp".to_string(), Value::Boolean(true));

    facts.add_value("TestCar", Value::Object(test_car_props))?;

    println!("🏁 Initial state:");
    if let Some(car) = facts.get("TestCar") {
        println!("   TestCar = {car:?}");
    }
    println!();

    // Create knowledge base and add rules from GRL file
    let kb = KnowledgeBase::new("MethodCallsDemo");

    // Parse rules from GRL file
    println!("🔧 Parsing GRL file content...");
    let rules = GRLParser::parse_rules(&rule_content)
        .map_err(|e| format!("Failed to parse GRL file: {:?}", e))?;

    println!("✅ Successfully parsed {} rules from file", rules.len());
    for rule in &rules {
        println!("   📋 Rule: {} (salience: {})", rule.name, rule.salience);
        let _ = kb.add_rule(rule.clone());
    }
    println!();

    // Create engine
    let config = EngineConfig {
        debug_mode: true,
        max_cycles: 5,
        ..Default::default()
    };
    let mut engine = RustRuleEngine::with_config(kb, config);

    // Register custom functions for speed control
    engine.register_function("increaseSpeed", |_args, facts| {
        if let Some(car) = facts.get("TestCar") {
            if let Value::Object(obj) = car {
                let current_speed = obj.get("Speed").cloned().unwrap_or(Value::Number(0.0));
                let increment = obj
                    .get("SpeedIncrement")
                    .cloned()
                    .unwrap_or(Value::Number(10.0));

                if let (Value::Number(speed), Value::Number(inc)) = (current_speed, increment) {
                    let new_speed = speed + inc;
                    println!("🚗 Increasing speed: {} -> {}", speed, new_speed);
                    // In real implementation, this would update the fact
                    return Ok(Value::Number(new_speed));
                }
            }
        }
        Ok(Value::String("Speed increase attempted".to_string()))
    });

    engine.register_function("decreaseSpeed", |_args, facts| {
        if let Some(car) = facts.get("TestCar") {
            if let Value::Object(obj) = car {
                let current_speed = obj.get("Speed").cloned().unwrap_or(Value::Number(0.0));
                let increment = obj
                    .get("SpeedIncrement")
                    .cloned()
                    .unwrap_or(Value::Number(10.0));

                if let (Value::Number(speed), Value::Number(inc)) = (current_speed, increment) {
                    let new_speed = (speed - inc).max(0.0);
                    println!("🚗 Decreasing speed: {} -> {}", speed, new_speed);
                    // In real implementation, this would update the fact
                    return Ok(Value::Number(new_speed));
                }
            }
        }
        Ok(Value::String("Speed decrease attempted".to_string()))
    });

    // Execute rules
    println!("🚀 Executing method calls rules from file...");
    let result = engine.execute(&facts)?;

    println!("\n📊 Method Calls Execution Results:");
    println!("   Cycles: {}", result.cycle_count);
    println!("   Rules evaluated: {}", result.rules_evaluated);
    println!("   Rules fired: {}", result.rules_fired);
    println!("   Execution time: {:?}", result.execution_time);

    println!("\n🏁 Final state:");
    if let Some(car) = facts.get("TestCar") {
        println!("   TestCar = {car:?}");
    }

    println!("\n🎯 Method Calls from Rule File Demonstrated:");
    println!("   📄 Rules defined in external .grl file");
    println!("   🔧 Method calls: setSpeed(), setSpeedUp()");
    println!("   📞 Custom functions: increaseSpeed(), decreaseSpeed()");
    println!("   🚗 Speed control simulation");
    println!("   ⚡ Salience-based rule execution order");

    Ok(())
}

examples/complete_speedup_demo.rs (line 24)

fn demo_complete_speedup_rule() -> std::result::Result<(), Box<dyn Error>> {
    println!("=== Demo: Complete SpeedUp Rule with Method Calls ===");
    println!("Implementing the exact rule from the requirement:");
    println!("rule \"SpeedUp\" salience 10");
    println!("when");
    println!("    $TestCar : TestCarClass( speedUp == true && speed < maxSpeed )");
    println!("    $DistanceRecord : DistanceRecordClass()");
    println!("then");
    println!("    $TestCar.setSpeed($TestCar.Speed + $TestCar.SpeedIncrement);");
    println!("    update($TestCar);");
    println!("    $DistanceRecord.setTotalDistance($DistanceRecord.getTotalDistance() + $TestCar.Speed);");
    println!("    update($DistanceRecord);");
    println!("end\n");

    // Create Knowledge Base
    let kb = KnowledgeBase::new("SpeedUpDemo");

    // For now, we'll use a simplified version that works with our current parser
    let speedup_rule = r#"rule "SpeedUp" salience 10 { 
        when TestCar.speedUp == true && TestCar.speed < TestCar.maxSpeed 
        then $TestCar.setSpeed($TestCar.Speed + $TestCar.SpeedIncrement); update($TestCar); $DistanceRecord.setTotalDistance($DistanceRecord.getTotalDistance() + $TestCar.Speed); update($DistanceRecord); 
    }"#;

    // Parse and add rule
    let rules = GRLParser::parse_rules(speedup_rule)?;
    let rule = rules.into_iter().next().unwrap();
    let _ = kb.add_rule(rule);

    // Create engine with debug mode
    let config = EngineConfig {
        max_cycles: 10,
        timeout: None,
        enable_stats: true,
        debug_mode: true,
    };
    let engine = RustRuleEngine::with_config(kb, config);

    // Create facts
    let facts = Facts::new();

    // Create TestCar object - initial speed less than max
    let test_car = FactHelper::create_test_car(
        true,  // speedUp
        30.0,  // speed (less than maxSpeed)
        100.0, // maxSpeed
        15.0,  // speedIncrement
    );

    // Create DistanceRecord object
    let distance_record = FactHelper::create_distance_record(0.0);

    // Add facts
    facts.add_value("TestCar", test_car)?;
    facts.add_value("DistanceRecord", distance_record)?;

    println!("🏁 Initial state:");
    if let Some(car) = facts.get("TestCar") {
        println!(
            "   TestCar.speed = {:?}",
            car.get_property("speed").unwrap_or(Value::Null)
        );
        println!(
            "   TestCar.Speed = {:?}",
            car.get_property("Speed").unwrap_or(Value::Null)
        );
        println!(
            "   TestCar.maxSpeed = {:?}",
            car.get_property("maxSpeed").unwrap_or(Value::Null)
        );
        println!(
            "   TestCar.speedUp = {:?}",
            car.get_property("speedUp").unwrap_or(Value::Null)
        );
        println!(
            "   TestCar.SpeedIncrement = {:?}",
            car.get_property("SpeedIncrement").unwrap_or(Value::Null)
        );
    }
    if let Some(record) = facts.get("DistanceRecord") {
        println!(
            "   DistanceRecord.TotalDistance = {:?}",
            record.get_property("TotalDistance").unwrap_or(Value::Null)
        );
    }

    // Execute rules multiple cycles
    println!("\n🚀 Executing SpeedUp rule...");
    for i in 1..=5 {
        println!("\n--- Cycle {} ---", i);
        let result = engine.execute(&facts)?;

        println!("Rules fired: {}", result.rules_fired);

        if let Some(car) = facts.get("TestCar") {
            println!(
                "TestCar.Speed = {:?}",
                car.get_property("Speed").unwrap_or(Value::Null)
            );
            println!(
                "TestCar.speed = {:?}",
                car.get_property("speed").unwrap_or(Value::Null)
            );
        }
        if let Some(record) = facts.get("DistanceRecord") {
            println!(
                "DistanceRecord.TotalDistance = {:?}",
                record.get_property("TotalDistance").unwrap_or(Value::Null)
            );
        }

        // Check if we reached max speed
        if let Some(car) = facts.get("TestCar") {
            if let Some(speed) = car.get_property("speed") {
                if let Some(max_speed) = car.get_property("maxSpeed") {
                    if speed.to_number() >= max_speed.to_number() {
                        println!("🏁 Max speed reached! Rule will no longer fire.");
                        break;
                    }
                }
            }
        }

        if result.rules_fired == 0 {
            println!("ℹ️ No rules fired this cycle.");
            break;
        }
    }

    println!("\n📊 Final Summary:");
    println!("✅ Successfully demonstrated method calls in GRL:");
    println!("   • Method calls: $Object.method(args)");
    println!("   • Property access: $Object.Property");
    println!("   • Arithmetic expressions: $A.prop + $B.prop");
    println!("   • update() function calls");
    println!("   • Complex conditions with && operator");

    Ok(())
}

Additional examples can be found in:

• examples/function_calls_demo.rs
• examples/inline_rules_demo.rs
• examples/rule_file_functions_demo.rs
• examples/custom_functions_demo.rs
• examples/fraud_detection.rs
• examples/ecommerce.rs

pub fn name(&self) -> &str

Get the knowledge base name

pub fn version(&self) -> u64

Get the current version of the knowledge base

pub fn add_rule(&self, rule: Rule) -> Result<()>

Add a rule to the knowledge base

Examples found in repository

examples/debug_conditions.rs (line 25)

fn test_simple_conditions() -> std::result::Result<(), Box<dyn Error>> {
    println!("=== Testing Simple Conditions ===");

    // Create Knowledge Base
    let kb = KnowledgeBase::new("TestConditions");

    // Test compound condition with &&
    let compound_rule = r#"rule "CompoundRule" { when TestCar.speedUp == true && TestCar.speed < TestCar.maxSpeed then TestCar.result = "compound_fired"; }"#;

    println!("Testing rule: {}", compound_rule);

    // Parse and add rule
    let rules = GRLParser::parse_rules(compound_rule)?;
    let rule = rules.into_iter().next().unwrap();
    println!("Parsed rule: {:?}", rule);

    let _ = kb.add_rule(rule);

    // Create engine with debug mode
    let config = EngineConfig {
        max_cycles: 10,
        timeout: None,
        enable_stats: true,
        debug_mode: true,
    };
    let engine = RustRuleEngine::with_config(kb, config);

    // Create facts
    let facts = Facts::new();

    // Create simple TestCar object with all needed properties
    let test_car = FactHelper::create_object(vec![
        ("speedUp", Value::Boolean(true)),
        ("speed", Value::Number(30.0)),
        ("maxSpeed", Value::Number(100.0)),
        ("result", Value::String("not_fired".to_string())),
    ]);

    facts.add_value("TestCar", test_car)?;

    println!("\n🏁 Before execution:");
    if let Some(car) = facts.get("TestCar") {
        println!("   TestCar.speedUp = {:?}", car.get_property("speedUp"));
        println!("   TestCar.speed = {:?}", car.get_property("speed"));
        println!("   TestCar.maxSpeed = {:?}", car.get_property("maxSpeed"));
        println!("   TestCar.result = {:?}", car.get_property("result"));
    }

    // Execute rules
    println!("\n🚀 Executing rule...");
    let result = engine.execute(&facts)?;

    println!("Rules fired: {}", result.rules_fired);

    println!("\n🏁 After execution:");
    if let Some(car) = facts.get("TestCar") {
        println!("   TestCar.speedUp = {:?}", car.get_property("speedUp"));
        println!("   TestCar.result = {:?}", car.get_property("result"));
    }

    Ok(())
}

examples/advanced_method_calls.rs (line 24)

fn demo_method_calls() -> std::result::Result<(), Box<dyn Error>> {
    println!("=== Demo: Advanced Method Calls ===");

    // Create Knowledge Base
    let kb = KnowledgeBase::new("MethodCallsDemo");

    // Define rule with simpler condition first
    let speedup_rule = r#"rule "SpeedUp" salience 10 { 
        when TestCar.speedUp == true 
        then TestCar.Speed = 70; 
    }"#;

    // Parse and add rule
    let rules = GRLParser::parse_rules(speedup_rule)?;
    let rule = rules.into_iter().next().unwrap();
    let _ = kb.add_rule(rule);

    // Create engine with debug mode
    let config = EngineConfig {
        max_cycles: 10,
        timeout: None,
        enable_stats: true,
        debug_mode: true,
    };
    let engine = RustRuleEngine::with_config(kb, config);

    // Create facts
    let facts = Facts::new();

    // Create TestCar object using helper
    let test_car = FactHelper::create_test_car(
        true,  // speedUp
        50.0,  // speed
        100.0, // maxSpeed
        10.0,  // speedIncrement
    );

    // Create DistanceRecord object using helper
    let distance_record = FactHelper::create_distance_record(0.0);

    // Add facts
    facts.add_value("TestCar", test_car)?;
    facts.add_value("DistanceRecord", distance_record)?;

    println!("\n🏁 Initial state:");
    if let Some(car) = facts.get("TestCar") {
        if let Some(speed) = car.get_property("Speed") {
            println!("   TestCar.Speed = {:?}", speed);
        }
        if let Some(speed_up) = car.get_property("speedUp") {
            println!("   TestCar.speedUp = {:?}", speed_up);
        }
    }

    // Execute rules multiple cycles to see progression
    println!("\n🚀 Executing SpeedUp rule multiple times...");
    for i in 1..=3 {
        println!("\n--- Cycle {} ---", i);
        let result = engine.execute(&facts)?;

        println!("Rules fired: {}", result.rules_fired);

        if let Some(car) = facts.get("TestCar") {
            if let Some(speed) = car.get_property("Speed") {
                println!("TestCar.Speed after cycle {}: {:?}", i, speed);
            }
        }

        // Check if we reached max speed
        if let Some(car) = facts.get("TestCar") {
            if let Some(speed) = car.get_property("speed") {
                if let Some(max_speed) = car.get_property("maxSpeed") {
                    if speed.to_number() >= max_speed.to_number() {
                        println!("🏁 Max speed reached!");
                        break;
                    }
                }
            }
        }
    }

    println!("\n📊 Final Results:");
    if let Some(car) = facts.get("TestCar") {
        if let Some(speed) = car.get_property("Speed") {
            println!("   Final TestCar.Speed = {:?}", speed);
        }
    }

    Ok(())
}

examples/generic_method_calls.rs (line 88)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Demo: Generic Method Calls ===\n");

    // Create objects with various properties
    let mut car_props = HashMap::new();
    car_props.insert("Speed".to_string(), Value::Number(50.0));
    car_props.insert("Fuel".to_string(), Value::Number(80.0));
    car_props.insert("Brand".to_string(), Value::String("Toyota".to_string()));

    let mut account_props = HashMap::new();
    account_props.insert("Balance".to_string(), Value::Number(1000.0));
    account_props.insert("Owner".to_string(), Value::String("John Doe".to_string()));
    account_props.insert("Active".to_string(), Value::Boolean(true));

    // Create facts
    let facts = Facts::new();
    facts.add_value("Car", Value::Object(car_props))?;
    facts.add_value("Account", Value::Object(account_props))?;

    println!("🏁 Initial state:");
    if let Some(car) = facts.get("Car") {
        println!("   Car = {car:?}");
    }
    if let Some(account) = facts.get("Account") {
        println!("   Account = {account:?}");
    }
    println!();

    // Create knowledge base
    let mut kb = KnowledgeBase::new("GenericMethodDemo");

    // Rule 1: Speed up car if speed < 60
    let speed_rule = Rule::new(
        "SpeedUpCar".to_string(),
        ConditionGroup::single(Condition::new(
            "Car.Speed".to_string(),
            Operator::LessThan,
            Value::Number(60.0),
        )),
        vec![ActionType::MethodCall {
            object: "Car".to_string(),
            method: "setSpeed".to_string(), // Generic setter
            args: vec![Value::Number(75.0)],
        }],
    )
    .with_salience(10);

    // Rule 2: Withdraw from account if balance > 500
    let withdraw_rule = Rule::new(
        "WithdrawMoney".to_string(),
        ConditionGroup::single(Condition::new(
            "Account.Balance".to_string(),
            Operator::GreaterThan,
            Value::Number(500.0),
        )),
        vec![ActionType::MethodCall {
            object: "Account".to_string(),
            method: "setBalance".to_string(), // Generic setter
            args: vec![Value::Number(800.0)],
        }],
    )
    .with_salience(5);

    // Rule 3: Update car brand using generic setter
    let brand_rule = Rule::new(
        "UpdateBrand".to_string(),
        ConditionGroup::single(Condition::new(
            "Car.Brand".to_string(),
            Operator::Equal,
            Value::String("Toyota".to_string()),
        )),
        vec![ActionType::MethodCall {
            object: "Car".to_string(),
            method: "setBrand".to_string(), // Generic setter
            args: vec![Value::String("Honda".to_string())],
        }],
    )
    .with_salience(3);

    // Add rules to knowledge base
    let _ = kb.add_rule(speed_rule);
    let _ = kb.add_rule(withdraw_rule);
    let _ = kb.add_rule(brand_rule);

    // Create engine with debug mode
    let config = EngineConfig {
        debug_mode: true,
        max_cycles: 10,
        ..Default::default()
    };
    let engine = RustRuleEngine::with_config(kb, config);

    // Execute rules
    println!("🚀 Executing rules with generic method calls...");
    let result = engine.execute(&facts)?;

    println!("\n📊 Execution Results:");
    println!("   Cycles: {}", result.cycle_count);
    println!("   Rules evaluated: {}", result.rules_evaluated);
    println!("   Rules fired: {}", result.rules_fired);
    println!("   Execution time: {:?}", result.execution_time);

    println!("\n🏁 Final state:");
    if let Some(car) = facts.get("Car") {
        println!("   Car = {car:?}");
    }
    if let Some(account) = facts.get("Account") {
        println!("   Account = {account:?}");
    }

    // Demonstrate generic getters
    println!("\n🔍 Testing generic getters:");
    if let Some(car_value) = facts.get("Car") {
        if let Value::Object(car_obj) = car_value {
            println!(
                "   Car.Speed via getter would return: {:?}",
                car_obj.get("Speed")
            );
            println!(
                "   Car.Brand via getter would return: {:?}",
                car_obj.get("Brand")
            );
            println!(
                "   Car.Fuel via getter would return: {:?}",
                car_obj.get("Fuel")
            );
        }
    }

    Ok(())
}

examples/method_calls_demo.rs (line 54)

fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    println!("🎯 Method Calls Demo with Rule File");
    println!("===================================\n");

    // Read rules from file
    let rule_file_path = "examples/rules/method_calls.grl";
    println!("📄 Reading rules from file: {}", rule_file_path);

    let rule_content = fs::read_to_string(rule_file_path)
        .map_err(|e| format!("Failed to read rule file: {}", e))?;

    println!("📋 Rule file content:");
    println!("---");
    println!("{}", rule_content);
    println!("---\n");

    // Create facts
    let facts = Facts::new();

    // TestCar data
    let mut test_car_props = HashMap::new();
    test_car_props.insert("Speed".to_string(), Value::Number(30.0));
    test_car_props.insert("MaxSpeed".to_string(), Value::Number(100.0));
    test_car_props.insert("SpeedIncrement".to_string(), Value::Number(10.0));
    test_car_props.insert("SpeedUp".to_string(), Value::Boolean(true));

    facts.add_value("TestCar", Value::Object(test_car_props))?;

    println!("🏁 Initial state:");
    if let Some(car) = facts.get("TestCar") {
        println!("   TestCar = {car:?}");
    }
    println!();

    // Create knowledge base and add rules from GRL file
    let kb = KnowledgeBase::new("MethodCallsDemo");

    // Parse rules from GRL file
    println!("🔧 Parsing GRL file content...");
    let rules = GRLParser::parse_rules(&rule_content)
        .map_err(|e| format!("Failed to parse GRL file: {:?}", e))?;

    println!("✅ Successfully parsed {} rules from file", rules.len());
    for rule in &rules {
        println!("   📋 Rule: {} (salience: {})", rule.name, rule.salience);
        let _ = kb.add_rule(rule.clone());
    }
    println!();

    // Create engine
    let config = EngineConfig {
        debug_mode: true,
        max_cycles: 5,
        ..Default::default()
    };
    let mut engine = RustRuleEngine::with_config(kb, config);

    // Register custom functions for speed control
    engine.register_function("increaseSpeed", |_args, facts| {
        if let Some(car) = facts.get("TestCar") {
            if let Value::Object(obj) = car {
                let current_speed = obj.get("Speed").cloned().unwrap_or(Value::Number(0.0));
                let increment = obj
                    .get("SpeedIncrement")
                    .cloned()
                    .unwrap_or(Value::Number(10.0));

                if let (Value::Number(speed), Value::Number(inc)) = (current_speed, increment) {
                    let new_speed = speed + inc;
                    println!("🚗 Increasing speed: {} -> {}", speed, new_speed);
                    // In real implementation, this would update the fact
                    return Ok(Value::Number(new_speed));
                }
            }
        }
        Ok(Value::String("Speed increase attempted".to_string()))
    });

    engine.register_function("decreaseSpeed", |_args, facts| {
        if let Some(car) = facts.get("TestCar") {
            if let Value::Object(obj) = car {
                let current_speed = obj.get("Speed").cloned().unwrap_or(Value::Number(0.0));
                let increment = obj
                    .get("SpeedIncrement")
                    .cloned()
                    .unwrap_or(Value::Number(10.0));

                if let (Value::Number(speed), Value::Number(inc)) = (current_speed, increment) {
                    let new_speed = (speed - inc).max(0.0);
                    println!("🚗 Decreasing speed: {} -> {}", speed, new_speed);
                    // In real implementation, this would update the fact
                    return Ok(Value::Number(new_speed));
                }
            }
        }
        Ok(Value::String("Speed decrease attempted".to_string()))
    });

    // Execute rules
    println!("🚀 Executing method calls rules from file...");
    let result = engine.execute(&facts)?;

    println!("\n📊 Method Calls Execution Results:");
    println!("   Cycles: {}", result.cycle_count);
    println!("   Rules evaluated: {}", result.rules_evaluated);
    println!("   Rules fired: {}", result.rules_fired);
    println!("   Execution time: {:?}", result.execution_time);

    println!("\n🏁 Final state:");
    if let Some(car) = facts.get("TestCar") {
        println!("   TestCar = {car:?}");
    }

    println!("\n🎯 Method Calls from Rule File Demonstrated:");
    println!("   📄 Rules defined in external .grl file");
    println!("   🔧 Method calls: setSpeed(), setSpeedUp()");
    println!("   📞 Custom functions: increaseSpeed(), decreaseSpeed()");
    println!("   🚗 Speed control simulation");
    println!("   ⚡ Salience-based rule execution order");

    Ok(())
}

examples/complete_speedup_demo.rs (line 35)

fn demo_complete_speedup_rule() -> std::result::Result<(), Box<dyn Error>> {
    println!("=== Demo: Complete SpeedUp Rule with Method Calls ===");
    println!("Implementing the exact rule from the requirement:");
    println!("rule \"SpeedUp\" salience 10");
    println!("when");
    println!("    $TestCar : TestCarClass( speedUp == true && speed < maxSpeed )");
    println!("    $DistanceRecord : DistanceRecordClass()");
    println!("then");
    println!("    $TestCar.setSpeed($TestCar.Speed + $TestCar.SpeedIncrement);");
    println!("    update($TestCar);");
    println!("    $DistanceRecord.setTotalDistance($DistanceRecord.getTotalDistance() + $TestCar.Speed);");
    println!("    update($DistanceRecord);");
    println!("end\n");

    // Create Knowledge Base
    let kb = KnowledgeBase::new("SpeedUpDemo");

    // For now, we'll use a simplified version that works with our current parser
    let speedup_rule = r#"rule "SpeedUp" salience 10 { 
        when TestCar.speedUp == true && TestCar.speed < TestCar.maxSpeed 
        then $TestCar.setSpeed($TestCar.Speed + $TestCar.SpeedIncrement); update($TestCar); $DistanceRecord.setTotalDistance($DistanceRecord.getTotalDistance() + $TestCar.Speed); update($DistanceRecord); 
    }"#;

    // Parse and add rule
    let rules = GRLParser::parse_rules(speedup_rule)?;
    let rule = rules.into_iter().next().unwrap();
    let _ = kb.add_rule(rule);

    // Create engine with debug mode
    let config = EngineConfig {
        max_cycles: 10,
        timeout: None,
        enable_stats: true,
        debug_mode: true,
    };
    let engine = RustRuleEngine::with_config(kb, config);

    // Create facts
    let facts = Facts::new();

    // Create TestCar object - initial speed less than max
    let test_car = FactHelper::create_test_car(
        true,  // speedUp
        30.0,  // speed (less than maxSpeed)
        100.0, // maxSpeed
        15.0,  // speedIncrement
    );

    // Create DistanceRecord object
    let distance_record = FactHelper::create_distance_record(0.0);

    // Add facts
    facts.add_value("TestCar", test_car)?;
    facts.add_value("DistanceRecord", distance_record)?;

    println!("🏁 Initial state:");
    if let Some(car) = facts.get("TestCar") {
        println!(
            "   TestCar.speed = {:?}",
            car.get_property("speed").unwrap_or(Value::Null)
        );
        println!(
            "   TestCar.Speed = {:?}",
            car.get_property("Speed").unwrap_or(Value::Null)
        );
        println!(
            "   TestCar.maxSpeed = {:?}",
            car.get_property("maxSpeed").unwrap_or(Value::Null)
        );
        println!(
            "   TestCar.speedUp = {:?}",
            car.get_property("speedUp").unwrap_or(Value::Null)
        );
        println!(
            "   TestCar.SpeedIncrement = {:?}",
            car.get_property("SpeedIncrement").unwrap_or(Value::Null)
        );
    }
    if let Some(record) = facts.get("DistanceRecord") {
        println!(
            "   DistanceRecord.TotalDistance = {:?}",
            record.get_property("TotalDistance").unwrap_or(Value::Null)
        );
    }

    // Execute rules multiple cycles
    println!("\n🚀 Executing SpeedUp rule...");
    for i in 1..=5 {
        println!("\n--- Cycle {} ---", i);
        let result = engine.execute(&facts)?;

        println!("Rules fired: {}", result.rules_fired);

        if let Some(car) = facts.get("TestCar") {
            println!(
                "TestCar.Speed = {:?}",
                car.get_property("Speed").unwrap_or(Value::Null)
            );
            println!(
                "TestCar.speed = {:?}",
                car.get_property("speed").unwrap_or(Value::Null)
            );
        }
        if let Some(record) = facts.get("DistanceRecord") {
            println!(
                "DistanceRecord.TotalDistance = {:?}",
                record.get_property("TotalDistance").unwrap_or(Value::Null)
            );
        }

        // Check if we reached max speed
        if let Some(car) = facts.get("TestCar") {
            if let Some(speed) = car.get_property("speed") {
                if let Some(max_speed) = car.get_property("maxSpeed") {
                    if speed.to_number() >= max_speed.to_number() {
                        println!("🏁 Max speed reached! Rule will no longer fire.");
                        break;
                    }
                }
            }
        }

        if result.rules_fired == 0 {
            println!("ℹ️ No rules fired this cycle.");
            break;
        }
    }

    println!("\n📊 Final Summary:");
    println!("✅ Successfully demonstrated method calls in GRL:");
    println!("   • Method calls: $Object.method(args)");
    println!("   • Property access: $Object.Property");
    println!("   • Arithmetic expressions: $A.prop + $B.prop");
    println!("   • update() function calls");
    println!("   • Complex conditions with && operator");

    Ok(())
}

examples/grule_demo.rs (line 191)

fn demo_engine_execution() -> std::result::Result<(), Box<dyn std::error::Error>> {
    println!("🚀 Demo 3: Engine Execution");
    println!("---------------------------");

    // Create facts
    let facts = Facts::new();
    let mut user_props = HashMap::new();
    user_props.insert("Age".to_string(), Value::Integer(25));
    user_props.insert("Country".to_string(), Value::String("US".to_string()));
    user_props.insert("SpendingTotal".to_string(), Value::Number(1500.0));
    user_props.insert("IsAdult".to_string(), Value::Boolean(false));
    user_props.insert("IsVIP".to_string(), Value::Boolean(false));
    user_props.insert("Category".to_string(), Value::String("unknown".to_string()));
    user_props.insert("DiscountRate".to_string(), Value::Number(0.0));

    facts.add_value("User", Value::Object(user_props))?;

    // Create knowledge base
    let mut kb = KnowledgeBase::new("UserRules");

    // Rule 1: Adult Check (salience 10)
    let adult_rule = Rule::new(
        "AdultCheck".to_string(),
        ConditionGroup::and(
            ConditionGroup::single(Condition::new(
                "User.Age".to_string(),
                Operator::GreaterThanOrEqual,
                Value::Integer(18),
            )),
            ConditionGroup::single(Condition::new(
                "User.Country".to_string(),
                Operator::Equal,
                Value::String("US".to_string()),
            )),
        ),
        vec![
            ActionType::MethodCall {
                object: "User".to_string(),
                method: "setIsAdult".to_string(),
                args: vec![Value::Boolean(true)],
            },
            ActionType::MethodCall {
                object: "User".to_string(),
                method: "setCategory".to_string(),
                args: vec![Value::String("Adult".to_string())],
            },
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String("User qualified as adult".to_string())],
            },
        ],
    )
    .with_salience(10);

    // Rule 2: VIP Check (salience 20)
    let vip_rule = Rule::new(
        "VIPCheck".to_string(),
        ConditionGroup::and(
            ConditionGroup::and(
                ConditionGroup::single(Condition::new(
                    "User.Age".to_string(),
                    Operator::GreaterThanOrEqual,
                    Value::Integer(21),
                )),
                ConditionGroup::single(Condition::new(
                    "User.IsAdult".to_string(),
                    Operator::Equal,
                    Value::Boolean(true),
                )),
            ),
            ConditionGroup::single(Condition::new(
                "User.SpendingTotal".to_string(),
                Operator::GreaterThan,
                Value::Number(1000.0),
            )),
        ),
        vec![
            ActionType::MethodCall {
                object: "User".to_string(),
                method: "setIsVIP".to_string(),
                args: vec![Value::Boolean(true)],
            },
            ActionType::MethodCall {
                object: "User".to_string(),
                method: "setDiscountRate".to_string(),
                args: vec![Value::Number(0.15)],
            },
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String("User upgraded to VIP".to_string())],
            },
        ],
    )
    .with_salience(20);

    // Rule 3: Senior Discount (salience 15)
    let senior_rule = Rule::new(
        "SeniorDiscount".to_string(),
        ConditionGroup::single(Condition::new(
            "User.Age".to_string(),
            Operator::GreaterThanOrEqual,
            Value::Integer(65),
        )),
        vec![
            ActionType::MethodCall {
                object: "User".to_string(),
                method: "setDiscountRate".to_string(),
                args: vec![Value::Number(0.20)],
            },
            ActionType::MethodCall {
                object: "User".to_string(),
                method: "setCategory".to_string(),
                args: vec![Value::String("Senior".to_string())],
            },
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String("Senior discount applied".to_string())],
            },
        ],
    )
    .with_salience(15);

    // Add rules to knowledge base
    let _ = kb.add_rule(adult_rule);
    let _ = kb.add_rule(vip_rule);
    let _ = kb.add_rule(senior_rule);

    // Create engine
    let config = EngineConfig {
        debug_mode: true,
        max_cycles: 3,
        ..Default::default()
    };
    let engine = RustRuleEngine::with_config(kb, config);

    println!("🏁 Initial state:");
    if let Some(user) = facts.get("User") {
        println!("   User = {user:?}");
    }
    println!();

    // Execute rules
    println!("🚀 Executing rules...");
    let result = engine.execute(&facts)?;

    println!("\n📊 Execution Results:");
    println!("   Cycles: {}", result.cycle_count);
    println!("   Rules evaluated: {}", result.rules_evaluated);
    println!("   Rules fired: {}", result.rules_fired);
    println!("   Execution time: {:?}", result.execution_time);

    println!("\n🏁 Final state:");
    if let Some(user) = facts.get("User") {
        println!("   User = {user:?}");
    }
    println!();

    Ok(())
}

fn demo_ecommerce_scenario() -> std::result::Result<(), Box<dyn std::error::Error>> {
    println!("🛒 Demo 4: E-commerce Scenario");
    println!("------------------------------");

    // Create facts
    let facts = Facts::new();

    // Customer data
    let mut customer_props = HashMap::new();
    customer_props.insert(
        "Email".to_string(),
        Value::String("customer@example.com".to_string()),
    );
    customer_props.insert("Age".to_string(), Value::Integer(28));
    customer_props.insert("IsNew".to_string(), Value::Boolean(true));
    customer_props.insert("LoyaltyPoints".to_string(), Value::Integer(0));
    customer_props.insert("TotalSpent".to_string(), Value::Number(0.0));

    // Order data
    let mut order_props = HashMap::new();
    order_props.insert("Id".to_string(), Value::String("ORD-12345".to_string()));
    order_props.insert("Amount".to_string(), Value::Number(150.0));
    order_props.insert(
        "Category".to_string(),
        Value::String("electronics".to_string()),
    );
    order_props.insert("DiscountPercent".to_string(), Value::Number(0.0));
    order_props.insert("FinalAmount".to_string(), Value::Number(150.0));

    facts.add_value("Customer", Value::Object(customer_props))?;
    facts.add_value("Order", Value::Object(order_props))?;

    // Create knowledge base
    let mut kb = KnowledgeBase::new("EcommerceRules");

    // Rule 1: New Customer Discount
    let new_customer_rule = Rule::new(
        "NewCustomerDiscount".to_string(),
        ConditionGroup::and(
            ConditionGroup::single(Condition::new(
                "Customer.IsNew".to_string(),
                Operator::Equal,
                Value::Boolean(true),
            )),
            ConditionGroup::single(Condition::new(
                "Order.Amount".to_string(),
                Operator::GreaterThan,
                Value::Number(100.0),
            )),
        ),
        vec![
            ActionType::MethodCall {
                object: "Order".to_string(),
                method: "setDiscountPercent".to_string(),
                args: vec![Value::Number(10.0)],
            },
            ActionType::MethodCall {
                object: "Customer".to_string(),
                method: "setLoyaltyPoints".to_string(),
                args: vec![Value::Integer(100)],
            },
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String("New customer discount applied".to_string())],
            },
        ],
    )
    .with_salience(10);

    // Rule 2: Calculate Final Amount
    let calculate_final_rule = Rule::new(
        "CalculateFinalAmount".to_string(),
        ConditionGroup::single(Condition::new(
            "Order.DiscountPercent".to_string(),
            Operator::GreaterThan,
            Value::Number(0.0),
        )),
        vec![ActionType::Call {
            function: "log".to_string(),
            args: vec![Value::String(
                "Calculating final amount with discount".to_string(),
            )],
        }],
    )
    .with_salience(5);

    // Add rules
    let _ = kb.add_rule(new_customer_rule);
    let _ = kb.add_rule(calculate_final_rule);

    // Create engine
    let config = EngineConfig {
        debug_mode: true,
        max_cycles: 3,
        ..Default::default()
    };
    let engine = RustRuleEngine::with_config(kb, config);

    println!("🏁 Initial e-commerce state:");
    if let Some(customer) = facts.get("Customer") {
        println!("   Customer = {customer:?}");
    }
    if let Some(order) = facts.get("Order") {
        println!("   Order = {order:?}");
    }
    println!();

    // Execute rules
    println!("🚀 Executing e-commerce rules...");
    let result = engine.execute(&facts)?;

    println!("\n📊 E-commerce Results:");
    println!("   Cycles: {}", result.cycle_count);
    println!("   Rules evaluated: {}", result.rules_evaluated);
    println!("   Rules fired: {}", result.rules_fired);
    println!("   Execution time: {:?}", result.execution_time);

    println!("\n🏁 Final e-commerce state:");
    if let Some(customer) = facts.get("Customer") {
        println!("   Customer = {customer:?}");
    }
    if let Some(order) = facts.get("Order") {
        println!("   Order = {order:?}");
    }

    println!("\n🎯 Demo Completed Successfully!");
    println!("   ✅ Knowledge Base management");
    println!("   ✅ Facts manipulation");
    println!("   ✅ Rule execution engine");
    println!("   ✅ E-commerce scenario");
    println!("   ✅ Method calls and function calls");
    println!("   ✅ Salience-based rule ordering");

    Ok(())
}

Additional examples can be found in:

• examples/function_calls_demo.rs
• examples/inline_rules_demo.rs
• examples/rule_file_functions_demo.rs
• examples/custom_functions_demo.rs
• examples/fraud_detection.rs
• examples/ecommerce.rs

pub fn add_rules_from_grl(&self, grl_text: &str) -> Result<usize>

Add multiple rules from GRL text

pub fn remove_rule(&self, rule_name: &str) -> Result<bool>

Remove a rule by name

pub fn get_rule(&self, rule_name: &str) -> Option<Rule>

Get a rule by name

pub fn get_rules(&self) -> Vec<Rule>

Get all rules

pub fn get_rule_names(&self) -> Vec<String>

Get all rule names

Examples found in repository

examples/ecommerce.rs (line 266)

fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    println!("=== E-commerce Rules Demo ===");
    println!("==============================\n");

    // Create customer data
    let mut customer_props = HashMap::new();
    customer_props.insert("IsNew".to_string(), Value::Boolean(true));
    customer_props.insert(
        "Membership".to_string(),
        Value::String("standard".to_string()),
    );
    customer_props.insert("TotalSpent".to_string(), Value::Number(750.0));
    customer_props.insert("WelcomeEmailSent".to_string(), Value::Boolean(false));

    // Create order data
    let mut order_props = HashMap::new();
    order_props.insert("Total".to_string(), Value::Number(75.0));
    order_props.insert("ItemCount".to_string(), Value::Integer(2));
    order_props.insert(
        "Category".to_string(),
        Value::String("clothing".to_string()),
    );
    order_props.insert("DiscountRate".to_string(), Value::Number(0.0));
    order_props.insert("FreeShipping".to_string(), Value::Boolean(false));
    order_props.insert(
        "DiscountType".to_string(),
        Value::String("none".to_string()),
    );

    // Create promotion data
    let mut promotion_props = HashMap::new();
    promotion_props.insert("SeasonalDiscount".to_string(), Value::Number(0.05));
    promotion_props.insert("BulkDiscount".to_string(), Value::Number(0.10));
    promotion_props.insert("Active".to_string(), Value::Boolean(true));

    // Create facts
    let facts = Facts::new();
    facts.add_value("Customer", Value::Object(customer_props))?;
    facts.add_value("Order", Value::Object(order_props))?;
    facts.add_value("Promotion", Value::Object(promotion_props))?;

    println!("🏁 Initial e-commerce data:");
    if let Some(customer) = facts.get("Customer") {
        println!("   Customer = {customer:?}");
    }
    if let Some(order) = facts.get("Order") {
        println!("   Order = {order:?}");
    }
    if let Some(promotion) = facts.get("Promotion") {
        println!("   Promotion = {promotion:?}");
    }
    println!();

    // Create knowledge base
    let mut kb = KnowledgeBase::new("EcommerceRules");

    // Rule 1: New Customer Discount (salience 25)
    let new_customer_rule = Rule::new(
        "NewCustomerDiscount".to_string(),
        ConditionGroup::and(
            ConditionGroup::single(Condition::new(
                "Customer.IsNew".to_string(),
                Operator::Equal,
                Value::Boolean(true),
            )),
            ConditionGroup::single(Condition::new(
                "Order.Total".to_string(),
                Operator::GreaterThan,
                Value::Number(50.0),
            )),
        ),
        vec![
            ActionType::MethodCall {
                object: "Order".to_string(),
                method: "setDiscountRate".to_string(),
                args: vec![Value::Number(0.10)],
            },
            ActionType::MethodCall {
                object: "Order".to_string(),
                method: "setDiscountType".to_string(),
                args: vec![Value::String("welcome".to_string())],
            },
            ActionType::MethodCall {
                object: "Customer".to_string(),
                method: "setWelcomeEmailSent".to_string(),
                args: vec![Value::Boolean(true)],
            },
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String(
                    "New customer welcome discount applied".to_string(),
                )],
            },
        ],
    )
    .with_salience(25);

    // Rule 2: Premium Member Benefits (salience 20)
    let premium_member_rule = Rule::new(
        "PremiumMemberBenefits".to_string(),
        ConditionGroup::and(
            ConditionGroup::single(Condition::new(
                "Customer.Membership".to_string(),
                Operator::Equal,
                Value::String("premium".to_string()),
            )),
            ConditionGroup::single(Condition::new(
                "Order.Total".to_string(),
                Operator::GreaterThan,
                Value::Number(100.0),
            )),
        ),
        vec![
            ActionType::MethodCall {
                object: "Order".to_string(),
                method: "setDiscountRate".to_string(),
                args: vec![Value::Number(0.15)],
            },
            ActionType::MethodCall {
                object: "Order".to_string(),
                method: "setFreeShipping".to_string(),
                args: vec![Value::Boolean(true)],
            },
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String("Premium member benefits applied".to_string())],
            },
        ],
    )
    .with_salience(20);

    // Rule 3: VIP Upgrade (salience 30)
    let vip_upgrade_rule = Rule::new(
        "VIPUpgrade".to_string(),
        ConditionGroup::and(
            ConditionGroup::single(Condition::new(
                "Customer.TotalSpent".to_string(),
                Operator::GreaterThan,
                Value::Number(1000.0),
            )),
            ConditionGroup::single(Condition::new(
                "Customer.Membership".to_string(),
                Operator::NotEqual,
                Value::String("VIP".to_string()),
            )),
        ),
        vec![
            ActionType::MethodCall {
                object: "Customer".to_string(),
                method: "setMembership".to_string(),
                args: vec![Value::String("VIP".to_string())],
            },
            ActionType::MethodCall {
                object: "Order".to_string(),
                method: "setDiscountRate".to_string(),
                args: vec![Value::Number(0.25)],
            },
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String(
                    "Customer upgraded to VIP membership".to_string(),
                )],
            },
        ],
    )
    .with_salience(30);

    // Rule 4: Free Shipping for Large Orders (salience 15)
    let free_shipping_rule = Rule::new(
        "FreeShippingLargeOrders".to_string(),
        ConditionGroup::single(Condition::new(
            "Order.Total".to_string(),
            Operator::GreaterThanOrEqual,
            Value::Number(100.0),
        )),
        vec![
            ActionType::MethodCall {
                object: "Order".to_string(),
                method: "setFreeShipping".to_string(),
                args: vec![Value::Boolean(true)],
            },
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String(
                    "Free shipping applied for large order".to_string(),
                )],
            },
        ],
    )
    .with_salience(15);

    // Rule 5: Bulk Discount (salience 12)
    let bulk_discount_rule = Rule::new(
        "BulkDiscount".to_string(),
        ConditionGroup::single(Condition::new(
            "Order.ItemCount".to_string(),
            Operator::GreaterThanOrEqual,
            Value::Integer(5),
        )),
        vec![
            ActionType::Call {
                function: "max".to_string(),
                args: vec![
                    Value::String("Order.DiscountRate".to_string()),
                    Value::Number(0.10),
                ],
            },
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String("Bulk discount applied".to_string())],
            },
        ],
    )
    .with_salience(12);

    // Rule 6: Seasonal Promotion (salience 10)
    let seasonal_promotion_rule = Rule::new(
        "SeasonalPromotion".to_string(),
        ConditionGroup::and(
            ConditionGroup::single(Condition::new(
                "Promotion.Active".to_string(),
                Operator::Equal,
                Value::Boolean(true),
            )),
            ConditionGroup::single(Condition::new(
                "Order.Category".to_string(),
                Operator::Equal,
                Value::String("clothing".to_string()),
            )),
        ),
        vec![
            ActionType::Call {
                function: "max".to_string(),
                args: vec![
                    Value::String("Order.DiscountRate".to_string()),
                    Value::String("Promotion.SeasonalDiscount".to_string()),
                ],
            },
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String("Seasonal promotion applied".to_string())],
            },
        ],
    )
    .with_salience(10);

    // Add rules to knowledge base
    let _ = kb.add_rule(new_customer_rule);
    let _ = kb.add_rule(premium_member_rule);
    let _ = kb.add_rule(vip_upgrade_rule);
    let _ = kb.add_rule(free_shipping_rule);
    let _ = kb.add_rule(bulk_discount_rule);
    let _ = kb.add_rule(seasonal_promotion_rule);

    println!(
        "📚 Knowledge Base loaded with {} rules",
        kb.get_statistics().total_rules
    );
    println!("🔥 Rules: {:?}\n", kb.get_rule_names());

    // Create engine with debug mode
    let config = EngineConfig {
        debug_mode: true,
        max_cycles: 5,
        ..Default::default()
    };
    let engine = RustRuleEngine::with_config(kb, config);

    // Execute rules
    println!("🚀 Executing e-commerce rules...");
    let result = engine.execute(&facts)?;

    println!("\n📊 E-commerce Execution Results:");
    println!("   Cycles: {}", result.cycle_count);
    println!("   Rules evaluated: {}", result.rules_evaluated);
    println!("   Rules fired: {}", result.rules_fired);
    println!("   Execution time: {:?}", result.execution_time);

    println!("\n🏁 Final e-commerce state:");
    if let Some(customer) = facts.get("Customer") {
        println!("   Customer = {customer:?}");
    }
    if let Some(order) = facts.get("Order") {
        println!("   Order = {order:?}");
    }
    if let Some(promotion) = facts.get("Promotion") {
        println!("   Promotion = {promotion:?}");
    }

    println!("\n🎯 E-commerce Rules Demonstrated:");
    println!("   🎁 New Customer Welcome Discount");
    println!("   💎 Premium Member Benefits");
    println!("   🌟 VIP Membership Upgrades");
    println!("   🚚 Free Shipping Rules");
    println!("   📦 Bulk Purchase Discounts");
    println!("   🏷️ Seasonal Promotions");

    Ok(())
}

pub fn rule_count(&self) -> usize

Get rule count

pub fn set_rule_enabled(&self, rule_name: &str, enabled: bool) -> Result<bool>

Enable or disable a rule

pub fn clear(&self)

Clear all rules

pub fn get_rules_snapshot(&self) -> Vec<Rule>

Get a snapshot of all rules (for execution)

pub fn get_statistics(&self) -> KnowledgeBaseStats

Get knowledge base statistics

Examples found in repository

examples/grule_demo.rs (line 34)

fn demo_knowledge_base() -> std::result::Result<(), Box<dyn std::error::Error>> {
    println!("📚 Demo 1: Knowledge Base with Code-based Rules");
    println!("-----------------------------------------------");

    // Create knowledge base
    let kb = KnowledgeBase::new("UserRules");

    println!("✅ Knowledge Base created: {}", kb.get_statistics().name);
    println!("   Total rules: {}", kb.get_statistics().total_rules);
    println!("   Version: {}\n", kb.get_statistics().version);

    Ok(())
}

examples/ecommerce.rs (line 264)

fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    println!("=== E-commerce Rules Demo ===");
    println!("==============================\n");

    // Create customer data
    let mut customer_props = HashMap::new();
    customer_props.insert("IsNew".to_string(), Value::Boolean(true));
    customer_props.insert(
        "Membership".to_string(),
        Value::String("standard".to_string()),
    );
    customer_props.insert("TotalSpent".to_string(), Value::Number(750.0));
    customer_props.insert("WelcomeEmailSent".to_string(), Value::Boolean(false));

    // Create order data
    let mut order_props = HashMap::new();
    order_props.insert("Total".to_string(), Value::Number(75.0));
    order_props.insert("ItemCount".to_string(), Value::Integer(2));
    order_props.insert(
        "Category".to_string(),
        Value::String("clothing".to_string()),
    );
    order_props.insert("DiscountRate".to_string(), Value::Number(0.0));
    order_props.insert("FreeShipping".to_string(), Value::Boolean(false));
    order_props.insert(
        "DiscountType".to_string(),
        Value::String("none".to_string()),
    );

    // Create promotion data
    let mut promotion_props = HashMap::new();
    promotion_props.insert("SeasonalDiscount".to_string(), Value::Number(0.05));
    promotion_props.insert("BulkDiscount".to_string(), Value::Number(0.10));
    promotion_props.insert("Active".to_string(), Value::Boolean(true));

    // Create facts
    let facts = Facts::new();
    facts.add_value("Customer", Value::Object(customer_props))?;
    facts.add_value("Order", Value::Object(order_props))?;
    facts.add_value("Promotion", Value::Object(promotion_props))?;

    println!("🏁 Initial e-commerce data:");
    if let Some(customer) = facts.get("Customer") {
        println!("   Customer = {customer:?}");
    }
    if let Some(order) = facts.get("Order") {
        println!("   Order = {order:?}");
    }
    if let Some(promotion) = facts.get("Promotion") {
        println!("   Promotion = {promotion:?}");
    }
    println!();

    // Create knowledge base
    let mut kb = KnowledgeBase::new("EcommerceRules");

    // Rule 1: New Customer Discount (salience 25)
    let new_customer_rule = Rule::new(
        "NewCustomerDiscount".to_string(),
        ConditionGroup::and(
            ConditionGroup::single(Condition::new(
                "Customer.IsNew".to_string(),
                Operator::Equal,
                Value::Boolean(true),
            )),
            ConditionGroup::single(Condition::new(
                "Order.Total".to_string(),
                Operator::GreaterThan,
                Value::Number(50.0),
            )),
        ),
        vec![
            ActionType::MethodCall {
                object: "Order".to_string(),
                method: "setDiscountRate".to_string(),
                args: vec![Value::Number(0.10)],
            },
            ActionType::MethodCall {
                object: "Order".to_string(),
                method: "setDiscountType".to_string(),
                args: vec![Value::String("welcome".to_string())],
            },
            ActionType::MethodCall {
                object: "Customer".to_string(),
                method: "setWelcomeEmailSent".to_string(),
                args: vec![Value::Boolean(true)],
            },
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String(
                    "New customer welcome discount applied".to_string(),
                )],
            },
        ],
    )
    .with_salience(25);

    // Rule 2: Premium Member Benefits (salience 20)
    let premium_member_rule = Rule::new(
        "PremiumMemberBenefits".to_string(),
        ConditionGroup::and(
            ConditionGroup::single(Condition::new(
                "Customer.Membership".to_string(),
                Operator::Equal,
                Value::String("premium".to_string()),
            )),
            ConditionGroup::single(Condition::new(
                "Order.Total".to_string(),
                Operator::GreaterThan,
                Value::Number(100.0),
            )),
        ),
        vec![
            ActionType::MethodCall {
                object: "Order".to_string(),
                method: "setDiscountRate".to_string(),
                args: vec![Value::Number(0.15)],
            },
            ActionType::MethodCall {
                object: "Order".to_string(),
                method: "setFreeShipping".to_string(),
                args: vec![Value::Boolean(true)],
            },
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String("Premium member benefits applied".to_string())],
            },
        ],
    )
    .with_salience(20);

    // Rule 3: VIP Upgrade (salience 30)
    let vip_upgrade_rule = Rule::new(
        "VIPUpgrade".to_string(),
        ConditionGroup::and(
            ConditionGroup::single(Condition::new(
                "Customer.TotalSpent".to_string(),
                Operator::GreaterThan,
                Value::Number(1000.0),
            )),
            ConditionGroup::single(Condition::new(
                "Customer.Membership".to_string(),
                Operator::NotEqual,
                Value::String("VIP".to_string()),
            )),
        ),
        vec![
            ActionType::MethodCall {
                object: "Customer".to_string(),
                method: "setMembership".to_string(),
                args: vec![Value::String("VIP".to_string())],
            },
            ActionType::MethodCall {
                object: "Order".to_string(),
                method: "setDiscountRate".to_string(),
                args: vec![Value::Number(0.25)],
            },
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String(
                    "Customer upgraded to VIP membership".to_string(),
                )],
            },
        ],
    )
    .with_salience(30);

    // Rule 4: Free Shipping for Large Orders (salience 15)
    let free_shipping_rule = Rule::new(
        "FreeShippingLargeOrders".to_string(),
        ConditionGroup::single(Condition::new(
            "Order.Total".to_string(),
            Operator::GreaterThanOrEqual,
            Value::Number(100.0),
        )),
        vec![
            ActionType::MethodCall {
                object: "Order".to_string(),
                method: "setFreeShipping".to_string(),
                args: vec![Value::Boolean(true)],
            },
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String(
                    "Free shipping applied for large order".to_string(),
                )],
            },
        ],
    )
    .with_salience(15);

    // Rule 5: Bulk Discount (salience 12)
    let bulk_discount_rule = Rule::new(
        "BulkDiscount".to_string(),
        ConditionGroup::single(Condition::new(
            "Order.ItemCount".to_string(),
            Operator::GreaterThanOrEqual,
            Value::Integer(5),
        )),
        vec![
            ActionType::Call {
                function: "max".to_string(),
                args: vec![
                    Value::String("Order.DiscountRate".to_string()),
                    Value::Number(0.10),
                ],
            },
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String("Bulk discount applied".to_string())],
            },
        ],
    )
    .with_salience(12);

    // Rule 6: Seasonal Promotion (salience 10)
    let seasonal_promotion_rule = Rule::new(
        "SeasonalPromotion".to_string(),
        ConditionGroup::and(
            ConditionGroup::single(Condition::new(
                "Promotion.Active".to_string(),
                Operator::Equal,
                Value::Boolean(true),
            )),
            ConditionGroup::single(Condition::new(
                "Order.Category".to_string(),
                Operator::Equal,
                Value::String("clothing".to_string()),
            )),
        ),
        vec![
            ActionType::Call {
                function: "max".to_string(),
                args: vec![
                    Value::String("Order.DiscountRate".to_string()),
                    Value::String("Promotion.SeasonalDiscount".to_string()),
                ],
            },
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String("Seasonal promotion applied".to_string())],
            },
        ],
    )
    .with_salience(10);

    // Add rules to knowledge base
    let _ = kb.add_rule(new_customer_rule);
    let _ = kb.add_rule(premium_member_rule);
    let _ = kb.add_rule(vip_upgrade_rule);
    let _ = kb.add_rule(free_shipping_rule);
    let _ = kb.add_rule(bulk_discount_rule);
    let _ = kb.add_rule(seasonal_promotion_rule);

    println!(
        "📚 Knowledge Base loaded with {} rules",
        kb.get_statistics().total_rules
    );
    println!("🔥 Rules: {:?}\n", kb.get_rule_names());

    // Create engine with debug mode
    let config = EngineConfig {
        debug_mode: true,
        max_cycles: 5,
        ..Default::default()
    };
    let engine = RustRuleEngine::with_config(kb, config);

    // Execute rules
    println!("🚀 Executing e-commerce rules...");
    let result = engine.execute(&facts)?;

    println!("\n📊 E-commerce Execution Results:");
    println!("   Cycles: {}", result.cycle_count);
    println!("   Rules evaluated: {}", result.rules_evaluated);
    println!("   Rules fired: {}", result.rules_fired);
    println!("   Execution time: {:?}", result.execution_time);

    println!("\n🏁 Final e-commerce state:");
    if let Some(customer) = facts.get("Customer") {
        println!("   Customer = {customer:?}");
    }
    if let Some(order) = facts.get("Order") {
        println!("   Order = {order:?}");
    }
    if let Some(promotion) = facts.get("Promotion") {
        println!("   Promotion = {promotion:?}");
    }

    println!("\n🎯 E-commerce Rules Demonstrated:");
    println!("   🎁 New Customer Welcome Discount");
    println!("   💎 Premium Member Benefits");
    println!("   🌟 VIP Membership Upgrades");
    println!("   🚚 Free Shipping Rules");
    println!("   📦 Bulk Purchase Discounts");
    println!("   🏷️ Seasonal Promotions");

    Ok(())
}

pub fn export_to_grl(&self) -> String

Export rules to GRL format

Trait Implementations

impl Clone for KnowledgeBase

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for KnowledgeBase

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.