Struct Rule 

pub struct Rule {
    pub name: String,
    pub description: Option<String>,
    pub salience: i32,
    pub enabled: bool,
    pub conditions: ConditionGroup,
    pub actions: Vec<ActionType>,
}

A rule with conditions and actions

Fields

name: String

The unique name of the rule

description: Option<String>

Optional description of what the rule does

salience: i32

Priority of the rule (higher values execute first)

enabled: bool

Whether the rule is enabled for execution

conditions: ConditionGroup

The conditions that must be met for the rule to fire

actions: Vec<ActionType>

The actions to execute when the rule fires

Implementations

impl Rule

pub fn new( name: String, conditions: ConditionGroup, actions: Vec<ActionType>, ) -> Self

Create a new rule with the given name, conditions, and actions

Examples found in repository

examples/generic_method_calls.rs (lines 40-52)

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/grule_demo.rs (lines 89-119)

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/function_calls_demo.rs (lines 47-61)

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

    // Create test data
    let mut user_props = HashMap::new();
    user_props.insert("Name".to_string(), Value::String("John Doe".to_string()));
    user_props.insert("Score".to_string(), Value::Number(85.5));
    user_props.insert("Active".to_string(), Value::Boolean(true));

    let numbers = vec![
        Value::Number(10.0),
        Value::Number(20.0),
        Value::Number(30.0),
        Value::Number(15.5),
        Value::Number(25.2),
    ];

    // Create facts
    let facts = Facts::new();
    facts.add_value("User", Value::Object(user_props))?;
    facts.add_value("Numbers", Value::Array(numbers))?;
    facts.add_value("Message", Value::String("Hello World".to_string()))?;

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

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

    // Rule 1: Log message if user is active
    let log_rule = Rule::new(
        "LogUserInfo".to_string(),
        ConditionGroup::single(Condition::new(
            "User.Active".to_string(),
            Operator::Equal,
            Value::Boolean(true),
        )),
        vec![ActionType::Call {
            function: "log".to_string(),
            args: vec![
                Value::String("User is active!".to_string()),
                Value::String("Processing user data...".to_string()),
            ],
        }],
    )
    .with_salience(10);

    // Rule 2: Calculate statistics if score > 80
    let stats_rule = Rule::new(
        "CalculateStats".to_string(),
        ConditionGroup::single(Condition::new(
            "User.Score".to_string(),
            Operator::GreaterThan,
            Value::Number(80.0),
        )),
        vec![
            ActionType::Call {
                function: "sum".to_string(),
                args: vec![
                    Value::Number(10.0),
                    Value::Number(20.0),
                    Value::Number(30.0),
                ],
            },
            ActionType::Call {
                function: "max".to_string(),
                args: vec![
                    Value::Number(85.5),
                    Value::Number(90.0),
                    Value::Number(78.2),
                ],
            },
            ActionType::Call {
                function: "average".to_string(),
                args: vec![
                    Value::Number(85.5),
                    Value::Number(90.0),
                    Value::Number(78.2),
                ],
            },
        ],
    )
    .with_salience(8);

    // Rule 3: String manipulation
    let string_rule = Rule::new(
        "StringManipulation".to_string(),
        ConditionGroup::single(Condition::new(
            "Message".to_string(),
            Operator::Contains,
            Value::String("Hello".to_string()),
        )),
        vec![
            ActionType::Call {
                function: "uppercase".to_string(),
                args: vec![Value::String("hello world".to_string())],
            },
            ActionType::Call {
                function: "contains".to_string(),
                args: vec![
                    Value::String("Hello World".to_string()),
                    Value::String("World".to_string()),
                ],
            },
            ActionType::Call {
                function: "format".to_string(),
                args: vec![
                    Value::String("User {0} has score {1}".to_string()),
                    Value::String("John Doe".to_string()),
                    Value::Number(85.5),
                ],
            },
        ],
    )
    .with_salience(6);

    // Rule 4: Mathematical functions
    let math_rule = Rule::new(
        "MathFunctions".to_string(),
        ConditionGroup::single(Condition::new(
            "User.Score".to_string(),
            Operator::GreaterThanOrEqual,
            Value::Number(80.0),
        )),
        vec![
            ActionType::Call {
                function: "round".to_string(),
                args: vec![Value::Number(85.7)],
            },
            ActionType::Call {
                function: "floor".to_string(),
                args: vec![Value::Number(85.7)],
            },
            ActionType::Call {
                function: "ceil".to_string(),
                args: vec![Value::Number(85.2)],
            },
            ActionType::Call {
                function: "abs".to_string(),
                args: vec![Value::Number(-42.5)],
            },
        ],
    )
    .with_salience(4);

    // Rule 5: Utility functions
    let utility_rule = Rule::new(
        "UtilityFunctions".to_string(),
        ConditionGroup::single(Condition::new(
            "User.Name".to_string(),
            Operator::NotEqual,
            Value::String("".to_string()),
        )),
        vec![
            ActionType::Call {
                function: "timestamp".to_string(),
                args: vec![],
            },
            ActionType::Call {
                function: "random".to_string(),
                args: vec![Value::Number(100.0)],
            },
            ActionType::Call {
                function: "length".to_string(),
                args: vec![Value::String("Hello World".to_string())],
            },
            ActionType::Call {
                function: "split".to_string(),
                args: vec![
                    Value::String("apple,banana,cherry".to_string()),
                    Value::String(",".to_string()),
                ],
            },
        ],
    )
    .with_salience(2);

    // Add rules to knowledge base
    let _ = kb.add_rule(log_rule);
    let _ = kb.add_rule(stats_rule);
    let _ = kb.add_rule(string_rule);
    let _ = kb.add_rule(math_rule);
    let _ = kb.add_rule(utility_rule);

    // 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 rules with generic function 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🎯 Function call examples demonstrated:");
    println!("   📋 Logging: log(), print()");
    println!("   🔢 Math: sum(), max(), average(), round(), floor(), ceil(), abs()");
    println!("   📝 String: uppercase(), contains(), format(), length(), split()");
    println!("   🛠️ Utility: timestamp(), random(), update()");
    println!("   🎨 Custom: Any user-defined function names");

    Ok(())
}

examples/custom_functions_demo.rs (lines 44-64)

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

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

    // Car data
    let mut car_props = HashMap::new();
    car_props.insert("Speed".to_string(), Value::Number(60.0));
    car_props.insert("MaxSpeed".to_string(), Value::Number(120.0));
    car_props.insert("Engine".to_string(), Value::String("V6".to_string()));
    car_props.insert("IsRunning".to_string(), Value::Boolean(true));

    // Driver data
    let mut driver_props = HashMap::new();
    driver_props.insert("Name".to_string(), Value::String("John Doe".to_string()));
    driver_props.insert("Experience".to_string(), Value::Integer(5));
    driver_props.insert("License".to_string(), Value::String("VALID".to_string()));

    facts.add_value("Car", Value::Object(car_props))?;
    facts.add_value("Driver", Value::Object(driver_props))?;

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

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

    // Rule 1: Speed Check with custom function
    let speed_check_rule = Rule::new(
        "SpeedCheck".to_string(),
        ConditionGroup::single(Condition::new(
            "Car.Speed".to_string(),
            Operator::GreaterThan,
            Value::Number(80.0),
        )),
        vec![
            ActionType::Call {
                function: "checkSpeedLimit".to_string(),
                args: vec![Value::String("Car.Speed".to_string()), Value::Number(80.0)],
            },
            ActionType::Call {
                function: "sendAlert".to_string(),
                args: vec![
                    Value::String("Speed limit exceeded!".to_string()),
                    Value::String("Driver.Name".to_string()),
                ],
            },
        ],
    )
    .with_salience(20);

    // Rule 2: Driver validation
    let driver_validation_rule = Rule::new(
        "DriverValidation".to_string(),
        ConditionGroup::single(Condition::new(
            "Driver.License".to_string(),
            Operator::Equal,
            Value::String("VALID".to_string()),
        )),
        vec![
            ActionType::Call {
                function: "validateDriver".to_string(),
                args: vec![
                    Value::String("Driver.Name".to_string()),
                    Value::String("Driver.Experience".to_string()),
                ],
            },
            ActionType::Call {
                function: "calculateInsurance".to_string(),
                args: vec![
                    Value::String("Driver.Experience".to_string()),
                    Value::String("Car.Engine".to_string()),
                ],
            },
        ],
    )
    .with_salience(15);

    // Rule 3: Engine diagnostics
    let engine_diagnostics_rule = Rule::new(
        "EngineDiagnostics".to_string(),
        ConditionGroup::single(Condition::new(
            "Car.IsRunning".to_string(),
            Operator::Equal,
            Value::Boolean(true),
        )),
        vec![
            ActionType::Call {
                function: "performDiagnostics".to_string(),
                args: vec![
                    Value::String("Car.Engine".to_string()),
                    Value::String("Car.Speed".to_string()),
                ],
            },
            ActionType::Call {
                function: "optimizePerformance".to_string(),
                args: vec![
                    Value::String("Car.Speed".to_string()),
                    Value::String("Car.MaxSpeed".to_string()),
                ],
            },
        ],
    )
    .with_salience(10);

    // Add rules to knowledge base
    let _ = kb.add_rule(speed_check_rule);
    let _ = kb.add_rule(driver_validation_rule);
    let _ = kb.add_rule(engine_diagnostics_rule);

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

    // Register custom functions
    println!("📝 Registering custom functions...");

    // Function 1: Check speed limit
    engine.register_function("checkSpeedLimit", |args, facts| {
        let speed_field = args.get(0).unwrap().to_string();
        let limit = args.get(1).unwrap();

        // Get actual speed value from facts
        let speed = if let Some(car) = facts.get("Car") {
            if let Value::Object(obj) = car {
                obj.get("Speed").cloned().unwrap_or(Value::Number(0.0))
            } else {
                Value::Number(0.0)
            }
        } else {
            Value::Number(0.0)
        };

        let result = format!("Speed check: {:?} vs limit {:?}", speed, limit);
        println!("🚦 {}", result);
        Ok(Value::String(result))
    });

    // Function 2: Send alert
    engine.register_function("sendAlert", |args, facts| {
        let message = args.get(0).unwrap().to_string();
        let driver_field = args.get(1).unwrap().to_string();

        // Get driver name from facts
        let driver_name = if let Some(driver) = facts.get("Driver") {
            if let Value::Object(obj) = driver {
                obj.get("Name")
                    .cloned()
                    .unwrap_or(Value::String("Unknown".to_string()))
            } else {
                Value::String("Unknown".to_string())
            }
        } else {
            Value::String("Unknown".to_string())
        };

        let alert = format!("🚨 ALERT to {:?}: {}", driver_name, message);
        println!("{}", alert);
        Ok(Value::String(alert))
    });

    // Function 3: Validate driver
    engine.register_function("validateDriver", |args, _facts| {
        let name_field = args.get(0).unwrap().to_string();
        let exp_field = args.get(1).unwrap().to_string();

        let result = format!(
            "✅ Driver validation passed for {} (experience: {})",
            name_field, exp_field
        );
        println!("{}", result);
        Ok(Value::String(result))
    });

    // Function 4: Calculate insurance
    engine.register_function("calculateInsurance", |args, _facts| {
        let exp_field = args.get(0).unwrap().to_string();
        let engine_field = args.get(1).unwrap().to_string();

        let result = format!(
            "💰 Insurance calculated: Experience {} + Engine {} = Premium rate",
            exp_field, engine_field
        );
        println!("{}", result);
        Ok(Value::String(result))
    });

    // Function 5: Perform diagnostics
    engine.register_function("performDiagnostics", |args, _facts| {
        let engine_field = args.get(0).unwrap().to_string();
        let speed_field = args.get(1).unwrap().to_string();

        let result = format!(
            "🔧 Diagnostics: Engine {} running at speed {} - All systems OK",
            engine_field, speed_field
        );
        println!("{}", result);
        Ok(Value::String(result))
    });

    // Function 6: Optimize performance
    engine.register_function("optimizePerformance", |args, _facts| {
        let current_speed = args.get(0).unwrap().to_string();
        let max_speed = args.get(1).unwrap().to_string();

        let result = format!(
            "⚡ Performance optimization: Current {} / Max {} - Efficiency tuned",
            current_speed, max_speed
        );
        println!("{}", result);
        Ok(Value::String(result))
    });

    println!("✅ Registered {} custom functions:", 6);
    println!("   🚦 checkSpeedLimit - Check if speed exceeds limit");
    println!("   🚨 sendAlert - Send alert message to driver");
    println!("   ✅ validateDriver - Validate driver credentials");
    println!("   💰 calculateInsurance - Calculate insurance premium");
    println!("   🔧 performDiagnostics - Run engine diagnostics");
    println!("   ⚡ optimizePerformance - Optimize engine performance");
    println!();

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

    println!("\n📊 Custom Function 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(driver) = facts.get("Driver") {
        println!("   Driver = {driver:?}");
    }

    println!("\n🎯 Custom Function Calls Demonstrated:");
    println!("   📞 User-defined functions called from rules");
    println!("   🔧 Custom business logic execution");
    println!("   🎪 Function registry system");
    println!("   📋 Rule-based custom function invocation");
    println!("   ⚡ Real-time function parameter resolution");

    Ok(())
}

examples/fraud_detection.rs (lines 59-90)

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

    // Create transaction data
    let mut transaction_props = HashMap::new();
    transaction_props.insert("Amount".to_string(), Value::Number(5000.0));
    transaction_props.insert("Location".to_string(), Value::String("FOREIGN".to_string()));
    transaction_props.insert("Time".to_string(), Value::String("02:30".to_string()));
    transaction_props.insert("CardType".to_string(), Value::String("CREDIT".to_string()));
    transaction_props.insert(
        "MerchantCategory".to_string(),
        Value::String("CASINO".to_string()),
    );

    let mut account_props = HashMap::new();
    account_props.insert("Balance".to_string(), Value::Number(2000.0));
    account_props.insert("DailyLimit".to_string(), Value::Number(3000.0));
    account_props.insert("RiskLevel".to_string(), Value::String("LOW".to_string()));
    account_props.insert("IsActive".to_string(), Value::Boolean(true));
    account_props.insert(
        "LastLoginLocation".to_string(),
        Value::String("DOMESTIC".to_string()),
    );

    let mut alert_props = HashMap::new();
    alert_props.insert("FraudScore".to_string(), Value::Number(0.0));
    alert_props.insert("Status".to_string(), Value::String("PENDING".to_string()));
    alert_props.insert("Alerts".to_string(), Value::Array(vec![]));

    // Create facts
    let facts = Facts::new();
    facts.add_value("Transaction", Value::Object(transaction_props))?;
    facts.add_value("Account", Value::Object(account_props))?;
    facts.add_value("Alert", Value::Object(alert_props))?;

    println!("🏁 Initial transaction data:");
    if let Some(transaction) = facts.get("Transaction") {
        println!("   Transaction = {transaction:?}");
    }
    if let Some(account) = facts.get("Account") {
        println!("   Account = {account:?}");
    }
    if let Some(alert) = facts.get("Alert") {
        println!("   Alert = {alert:?}");
    }
    println!();

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

    // Rule 1: High Amount Transaction Alert
    let high_amount_rule = Rule::new(
        "HighAmountAlert".to_string(),
        ConditionGroup::and(
            ConditionGroup::single(Condition::new(
                "Transaction.Amount".to_string(),
                Operator::GreaterThan,
                Value::Number(3000.0),
            )),
            ConditionGroup::single(Condition::new(
                "Account.DailyLimit".to_string(),
                Operator::LessThan,
                Value::String("Transaction.Amount".to_string()),
            )),
        ),
        vec![
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String(
                    "HIGH AMOUNT ALERT: Transaction exceeds daily limit".to_string(),
                )],
            },
            ActionType::MethodCall {
                object: "Alert".to_string(),
                method: "setFraudScore".to_string(),
                args: vec![Value::Number(50.0)],
            },
            ActionType::Set {
                field: "Alert.Status".to_string(),
                value: Value::String("FLAGGED".to_string()),
            },
        ],
    )
    .with_salience(10);

    // Rule 2: Foreign Location Alert
    let foreign_location_rule = Rule::new(
        "ForeignLocationAlert".to_string(),
        ConditionGroup::and(
            ConditionGroup::single(Condition::new(
                "Transaction.Location".to_string(),
                Operator::Equal,
                Value::String("FOREIGN".to_string()),
            )),
            ConditionGroup::single(Condition::new(
                "Account.LastLoginLocation".to_string(),
                Operator::Equal,
                Value::String("DOMESTIC".to_string()),
            )),
        ),
        vec![
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String(
                    "LOCATION ALERT: Foreign transaction detected".to_string(),
                )],
            },
            ActionType::Call {
                function: "sum".to_string(),
                args: vec![
                    Value::String("Alert.FraudScore".to_string()),
                    Value::Number(30.0),
                ],
            },
        ],
    )
    .with_salience(8);

    // Rule 3: Late Night Transaction Alert
    let late_night_rule = Rule::new(
        "LateNightAlert".to_string(),
        ConditionGroup::single(Condition::new(
            "Transaction.Time".to_string(),
            Operator::Contains,
            Value::String("02:".to_string()),
        )),
        vec![
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String(
                    "TIME ALERT: Late night transaction".to_string(),
                )],
            },
            ActionType::MethodCall {
                object: "Alert".to_string(),
                method: "setFraudScore".to_string(),
                args: vec![Value::Number(20.0)],
            },
        ],
    )
    .with_salience(6);

    // Rule 4: High Risk Merchant Category
    let high_risk_merchant_rule = Rule::new(
        "HighRiskMerchantAlert".to_string(),
        ConditionGroup::single(Condition::new(
            "Transaction.MerchantCategory".to_string(),
            Operator::Equal,
            Value::String("CASINO".to_string()),
        )),
        vec![
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String(
                    "MERCHANT ALERT: High-risk merchant category".to_string(),
                )],
            },
            ActionType::MethodCall {
                object: "Alert".to_string(),
                method: "setFraudScore".to_string(),
                args: vec![Value::Number(40.0)],
            },
        ],
    )
    .with_salience(7);

    // Rule 5: Critical Fraud Score Alert
    let critical_fraud_rule = Rule::new(
        "CriticalFraudAlert".to_string(),
        ConditionGroup::single(Condition::new(
            "Alert.FraudScore".to_string(),
            Operator::GreaterThanOrEqual,
            Value::Number(70.0),
        )),
        vec![
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String(
                    "🚨 CRITICAL FRAUD ALERT! Blocking transaction!".to_string(),
                )],
            },
            ActionType::Set {
                field: "Alert.Status".to_string(),
                value: Value::String("BLOCKED".to_string()),
            },
            ActionType::Call {
                function: "format".to_string(),
                args: vec![
                    Value::String("Transaction #{0} BLOCKED - Fraud Score: {1}".to_string()),
                    Value::String("TX123456".to_string()),
                    Value::String("Alert.FraudScore".to_string()),
                ],
            },
        ],
    )
    .with_salience(15);

    // Rule 6: Account Insufficient Funds
    let insufficient_funds_rule = Rule::new(
        "InsufficientFundsAlert".to_string(),
        ConditionGroup::single(Condition::new(
            "Account.Balance".to_string(),
            Operator::LessThan,
            Value::String("Transaction.Amount".to_string()),
        )),
        vec![
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String(
                    "💰 INSUFFICIENT FUNDS: Transaction declined".to_string(),
                )],
            },
            ActionType::Set {
                field: "Alert.Status".to_string(),
                value: Value::String("DECLINED".to_string()),
            },
        ],
    )
    .with_salience(20); // Highest priority

    // Add rules to knowledge base
    let _ = kb.add_rule(high_amount_rule);
    let _ = kb.add_rule(foreign_location_rule);
    let _ = kb.add_rule(late_night_rule);
    let _ = kb.add_rule(high_risk_merchant_rule);
    let _ = kb.add_rule(critical_fraud_rule);
    let _ = kb.add_rule(insufficient_funds_rule);

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

    println!("🔍 Running fraud detection analysis...");
    let result = engine.execute(&facts)?;

    println!("\n📊 Fraud Detection 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 analysis:");
    if let Some(transaction) = facts.get("Transaction") {
        println!("   Transaction = {transaction:?}");
    }
    if let Some(account) = facts.get("Account") {
        println!("   Account = {account:?}");
    }
    if let Some(alert) = facts.get("Alert") {
        println!("   Alert = {alert:?}");
    }

    println!("\n🎯 Fraud Detection Rules Demonstrated:");
    println!("   🚨 High Amount Transactions");
    println!("   🌍 Foreign Location Detection");
    println!("   🌙 Late Night Activity");
    println!("   🎰 High-Risk Merchant Categories");
    println!("   ⚠️ Critical Fraud Score Alerts");
    println!("   💰 Insufficient Funds Checks");

    Ok(())
}

examples/ecommerce.rs (lines 65-102)

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 with_description(self, description: String) -> Self

Add a description to the rule

pub fn with_salience(self, salience: i32) -> Self

Set the salience (priority) of the rule

Examples found in repository

examples/generic_method_calls.rs (line 53)

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/grule_demo.rs (line 120)

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/function_calls_demo.rs (line 62)

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

    // Create test data
    let mut user_props = HashMap::new();
    user_props.insert("Name".to_string(), Value::String("John Doe".to_string()));
    user_props.insert("Score".to_string(), Value::Number(85.5));
    user_props.insert("Active".to_string(), Value::Boolean(true));

    let numbers = vec![
        Value::Number(10.0),
        Value::Number(20.0),
        Value::Number(30.0),
        Value::Number(15.5),
        Value::Number(25.2),
    ];

    // Create facts
    let facts = Facts::new();
    facts.add_value("User", Value::Object(user_props))?;
    facts.add_value("Numbers", Value::Array(numbers))?;
    facts.add_value("Message", Value::String("Hello World".to_string()))?;

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

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

    // Rule 1: Log message if user is active
    let log_rule = Rule::new(
        "LogUserInfo".to_string(),
        ConditionGroup::single(Condition::new(
            "User.Active".to_string(),
            Operator::Equal,
            Value::Boolean(true),
        )),
        vec![ActionType::Call {
            function: "log".to_string(),
            args: vec![
                Value::String("User is active!".to_string()),
                Value::String("Processing user data...".to_string()),
            ],
        }],
    )
    .with_salience(10);

    // Rule 2: Calculate statistics if score > 80
    let stats_rule = Rule::new(
        "CalculateStats".to_string(),
        ConditionGroup::single(Condition::new(
            "User.Score".to_string(),
            Operator::GreaterThan,
            Value::Number(80.0),
        )),
        vec![
            ActionType::Call {
                function: "sum".to_string(),
                args: vec![
                    Value::Number(10.0),
                    Value::Number(20.0),
                    Value::Number(30.0),
                ],
            },
            ActionType::Call {
                function: "max".to_string(),
                args: vec![
                    Value::Number(85.5),
                    Value::Number(90.0),
                    Value::Number(78.2),
                ],
            },
            ActionType::Call {
                function: "average".to_string(),
                args: vec![
                    Value::Number(85.5),
                    Value::Number(90.0),
                    Value::Number(78.2),
                ],
            },
        ],
    )
    .with_salience(8);

    // Rule 3: String manipulation
    let string_rule = Rule::new(
        "StringManipulation".to_string(),
        ConditionGroup::single(Condition::new(
            "Message".to_string(),
            Operator::Contains,
            Value::String("Hello".to_string()),
        )),
        vec![
            ActionType::Call {
                function: "uppercase".to_string(),
                args: vec![Value::String("hello world".to_string())],
            },
            ActionType::Call {
                function: "contains".to_string(),
                args: vec![
                    Value::String("Hello World".to_string()),
                    Value::String("World".to_string()),
                ],
            },
            ActionType::Call {
                function: "format".to_string(),
                args: vec![
                    Value::String("User {0} has score {1}".to_string()),
                    Value::String("John Doe".to_string()),
                    Value::Number(85.5),
                ],
            },
        ],
    )
    .with_salience(6);

    // Rule 4: Mathematical functions
    let math_rule = Rule::new(
        "MathFunctions".to_string(),
        ConditionGroup::single(Condition::new(
            "User.Score".to_string(),
            Operator::GreaterThanOrEqual,
            Value::Number(80.0),
        )),
        vec![
            ActionType::Call {
                function: "round".to_string(),
                args: vec![Value::Number(85.7)],
            },
            ActionType::Call {
                function: "floor".to_string(),
                args: vec![Value::Number(85.7)],
            },
            ActionType::Call {
                function: "ceil".to_string(),
                args: vec![Value::Number(85.2)],
            },
            ActionType::Call {
                function: "abs".to_string(),
                args: vec![Value::Number(-42.5)],
            },
        ],
    )
    .with_salience(4);

    // Rule 5: Utility functions
    let utility_rule = Rule::new(
        "UtilityFunctions".to_string(),
        ConditionGroup::single(Condition::new(
            "User.Name".to_string(),
            Operator::NotEqual,
            Value::String("".to_string()),
        )),
        vec![
            ActionType::Call {
                function: "timestamp".to_string(),
                args: vec![],
            },
            ActionType::Call {
                function: "random".to_string(),
                args: vec![Value::Number(100.0)],
            },
            ActionType::Call {
                function: "length".to_string(),
                args: vec![Value::String("Hello World".to_string())],
            },
            ActionType::Call {
                function: "split".to_string(),
                args: vec![
                    Value::String("apple,banana,cherry".to_string()),
                    Value::String(",".to_string()),
                ],
            },
        ],
    )
    .with_salience(2);

    // Add rules to knowledge base
    let _ = kb.add_rule(log_rule);
    let _ = kb.add_rule(stats_rule);
    let _ = kb.add_rule(string_rule);
    let _ = kb.add_rule(math_rule);
    let _ = kb.add_rule(utility_rule);

    // 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 rules with generic function 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🎯 Function call examples demonstrated:");
    println!("   📋 Logging: log(), print()");
    println!("   🔢 Math: sum(), max(), average(), round(), floor(), ceil(), abs()");
    println!("   📝 String: uppercase(), contains(), format(), length(), split()");
    println!("   🛠️ Utility: timestamp(), random(), update()");
    println!("   🎨 Custom: Any user-defined function names");

    Ok(())
}

examples/custom_functions_demo.rs (line 65)

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

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

    // Car data
    let mut car_props = HashMap::new();
    car_props.insert("Speed".to_string(), Value::Number(60.0));
    car_props.insert("MaxSpeed".to_string(), Value::Number(120.0));
    car_props.insert("Engine".to_string(), Value::String("V6".to_string()));
    car_props.insert("IsRunning".to_string(), Value::Boolean(true));

    // Driver data
    let mut driver_props = HashMap::new();
    driver_props.insert("Name".to_string(), Value::String("John Doe".to_string()));
    driver_props.insert("Experience".to_string(), Value::Integer(5));
    driver_props.insert("License".to_string(), Value::String("VALID".to_string()));

    facts.add_value("Car", Value::Object(car_props))?;
    facts.add_value("Driver", Value::Object(driver_props))?;

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

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

    // Rule 1: Speed Check with custom function
    let speed_check_rule = Rule::new(
        "SpeedCheck".to_string(),
        ConditionGroup::single(Condition::new(
            "Car.Speed".to_string(),
            Operator::GreaterThan,
            Value::Number(80.0),
        )),
        vec![
            ActionType::Call {
                function: "checkSpeedLimit".to_string(),
                args: vec![Value::String("Car.Speed".to_string()), Value::Number(80.0)],
            },
            ActionType::Call {
                function: "sendAlert".to_string(),
                args: vec![
                    Value::String("Speed limit exceeded!".to_string()),
                    Value::String("Driver.Name".to_string()),
                ],
            },
        ],
    )
    .with_salience(20);

    // Rule 2: Driver validation
    let driver_validation_rule = Rule::new(
        "DriverValidation".to_string(),
        ConditionGroup::single(Condition::new(
            "Driver.License".to_string(),
            Operator::Equal,
            Value::String("VALID".to_string()),
        )),
        vec![
            ActionType::Call {
                function: "validateDriver".to_string(),
                args: vec![
                    Value::String("Driver.Name".to_string()),
                    Value::String("Driver.Experience".to_string()),
                ],
            },
            ActionType::Call {
                function: "calculateInsurance".to_string(),
                args: vec![
                    Value::String("Driver.Experience".to_string()),
                    Value::String("Car.Engine".to_string()),
                ],
            },
        ],
    )
    .with_salience(15);

    // Rule 3: Engine diagnostics
    let engine_diagnostics_rule = Rule::new(
        "EngineDiagnostics".to_string(),
        ConditionGroup::single(Condition::new(
            "Car.IsRunning".to_string(),
            Operator::Equal,
            Value::Boolean(true),
        )),
        vec![
            ActionType::Call {
                function: "performDiagnostics".to_string(),
                args: vec![
                    Value::String("Car.Engine".to_string()),
                    Value::String("Car.Speed".to_string()),
                ],
            },
            ActionType::Call {
                function: "optimizePerformance".to_string(),
                args: vec![
                    Value::String("Car.Speed".to_string()),
                    Value::String("Car.MaxSpeed".to_string()),
                ],
            },
        ],
    )
    .with_salience(10);

    // Add rules to knowledge base
    let _ = kb.add_rule(speed_check_rule);
    let _ = kb.add_rule(driver_validation_rule);
    let _ = kb.add_rule(engine_diagnostics_rule);

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

    // Register custom functions
    println!("📝 Registering custom functions...");

    // Function 1: Check speed limit
    engine.register_function("checkSpeedLimit", |args, facts| {
        let speed_field = args.get(0).unwrap().to_string();
        let limit = args.get(1).unwrap();

        // Get actual speed value from facts
        let speed = if let Some(car) = facts.get("Car") {
            if let Value::Object(obj) = car {
                obj.get("Speed").cloned().unwrap_or(Value::Number(0.0))
            } else {
                Value::Number(0.0)
            }
        } else {
            Value::Number(0.0)
        };

        let result = format!("Speed check: {:?} vs limit {:?}", speed, limit);
        println!("🚦 {}", result);
        Ok(Value::String(result))
    });

    // Function 2: Send alert
    engine.register_function("sendAlert", |args, facts| {
        let message = args.get(0).unwrap().to_string();
        let driver_field = args.get(1).unwrap().to_string();

        // Get driver name from facts
        let driver_name = if let Some(driver) = facts.get("Driver") {
            if let Value::Object(obj) = driver {
                obj.get("Name")
                    .cloned()
                    .unwrap_or(Value::String("Unknown".to_string()))
            } else {
                Value::String("Unknown".to_string())
            }
        } else {
            Value::String("Unknown".to_string())
        };

        let alert = format!("🚨 ALERT to {:?}: {}", driver_name, message);
        println!("{}", alert);
        Ok(Value::String(alert))
    });

    // Function 3: Validate driver
    engine.register_function("validateDriver", |args, _facts| {
        let name_field = args.get(0).unwrap().to_string();
        let exp_field = args.get(1).unwrap().to_string();

        let result = format!(
            "✅ Driver validation passed for {} (experience: {})",
            name_field, exp_field
        );
        println!("{}", result);
        Ok(Value::String(result))
    });

    // Function 4: Calculate insurance
    engine.register_function("calculateInsurance", |args, _facts| {
        let exp_field = args.get(0).unwrap().to_string();
        let engine_field = args.get(1).unwrap().to_string();

        let result = format!(
            "💰 Insurance calculated: Experience {} + Engine {} = Premium rate",
            exp_field, engine_field
        );
        println!("{}", result);
        Ok(Value::String(result))
    });

    // Function 5: Perform diagnostics
    engine.register_function("performDiagnostics", |args, _facts| {
        let engine_field = args.get(0).unwrap().to_string();
        let speed_field = args.get(1).unwrap().to_string();

        let result = format!(
            "🔧 Diagnostics: Engine {} running at speed {} - All systems OK",
            engine_field, speed_field
        );
        println!("{}", result);
        Ok(Value::String(result))
    });

    // Function 6: Optimize performance
    engine.register_function("optimizePerformance", |args, _facts| {
        let current_speed = args.get(0).unwrap().to_string();
        let max_speed = args.get(1).unwrap().to_string();

        let result = format!(
            "⚡ Performance optimization: Current {} / Max {} - Efficiency tuned",
            current_speed, max_speed
        );
        println!("{}", result);
        Ok(Value::String(result))
    });

    println!("✅ Registered {} custom functions:", 6);
    println!("   🚦 checkSpeedLimit - Check if speed exceeds limit");
    println!("   🚨 sendAlert - Send alert message to driver");
    println!("   ✅ validateDriver - Validate driver credentials");
    println!("   💰 calculateInsurance - Calculate insurance premium");
    println!("   🔧 performDiagnostics - Run engine diagnostics");
    println!("   ⚡ optimizePerformance - Optimize engine performance");
    println!();

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

    println!("\n📊 Custom Function 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(driver) = facts.get("Driver") {
        println!("   Driver = {driver:?}");
    }

    println!("\n🎯 Custom Function Calls Demonstrated:");
    println!("   📞 User-defined functions called from rules");
    println!("   🔧 Custom business logic execution");
    println!("   🎪 Function registry system");
    println!("   📋 Rule-based custom function invocation");
    println!("   ⚡ Real-time function parameter resolution");

    Ok(())
}

examples/fraud_detection.rs (line 91)

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

    // Create transaction data
    let mut transaction_props = HashMap::new();
    transaction_props.insert("Amount".to_string(), Value::Number(5000.0));
    transaction_props.insert("Location".to_string(), Value::String("FOREIGN".to_string()));
    transaction_props.insert("Time".to_string(), Value::String("02:30".to_string()));
    transaction_props.insert("CardType".to_string(), Value::String("CREDIT".to_string()));
    transaction_props.insert(
        "MerchantCategory".to_string(),
        Value::String("CASINO".to_string()),
    );

    let mut account_props = HashMap::new();
    account_props.insert("Balance".to_string(), Value::Number(2000.0));
    account_props.insert("DailyLimit".to_string(), Value::Number(3000.0));
    account_props.insert("RiskLevel".to_string(), Value::String("LOW".to_string()));
    account_props.insert("IsActive".to_string(), Value::Boolean(true));
    account_props.insert(
        "LastLoginLocation".to_string(),
        Value::String("DOMESTIC".to_string()),
    );

    let mut alert_props = HashMap::new();
    alert_props.insert("FraudScore".to_string(), Value::Number(0.0));
    alert_props.insert("Status".to_string(), Value::String("PENDING".to_string()));
    alert_props.insert("Alerts".to_string(), Value::Array(vec![]));

    // Create facts
    let facts = Facts::new();
    facts.add_value("Transaction", Value::Object(transaction_props))?;
    facts.add_value("Account", Value::Object(account_props))?;
    facts.add_value("Alert", Value::Object(alert_props))?;

    println!("🏁 Initial transaction data:");
    if let Some(transaction) = facts.get("Transaction") {
        println!("   Transaction = {transaction:?}");
    }
    if let Some(account) = facts.get("Account") {
        println!("   Account = {account:?}");
    }
    if let Some(alert) = facts.get("Alert") {
        println!("   Alert = {alert:?}");
    }
    println!();

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

    // Rule 1: High Amount Transaction Alert
    let high_amount_rule = Rule::new(
        "HighAmountAlert".to_string(),
        ConditionGroup::and(
            ConditionGroup::single(Condition::new(
                "Transaction.Amount".to_string(),
                Operator::GreaterThan,
                Value::Number(3000.0),
            )),
            ConditionGroup::single(Condition::new(
                "Account.DailyLimit".to_string(),
                Operator::LessThan,
                Value::String("Transaction.Amount".to_string()),
            )),
        ),
        vec![
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String(
                    "HIGH AMOUNT ALERT: Transaction exceeds daily limit".to_string(),
                )],
            },
            ActionType::MethodCall {
                object: "Alert".to_string(),
                method: "setFraudScore".to_string(),
                args: vec![Value::Number(50.0)],
            },
            ActionType::Set {
                field: "Alert.Status".to_string(),
                value: Value::String("FLAGGED".to_string()),
            },
        ],
    )
    .with_salience(10);

    // Rule 2: Foreign Location Alert
    let foreign_location_rule = Rule::new(
        "ForeignLocationAlert".to_string(),
        ConditionGroup::and(
            ConditionGroup::single(Condition::new(
                "Transaction.Location".to_string(),
                Operator::Equal,
                Value::String("FOREIGN".to_string()),
            )),
            ConditionGroup::single(Condition::new(
                "Account.LastLoginLocation".to_string(),
                Operator::Equal,
                Value::String("DOMESTIC".to_string()),
            )),
        ),
        vec![
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String(
                    "LOCATION ALERT: Foreign transaction detected".to_string(),
                )],
            },
            ActionType::Call {
                function: "sum".to_string(),
                args: vec![
                    Value::String("Alert.FraudScore".to_string()),
                    Value::Number(30.0),
                ],
            },
        ],
    )
    .with_salience(8);

    // Rule 3: Late Night Transaction Alert
    let late_night_rule = Rule::new(
        "LateNightAlert".to_string(),
        ConditionGroup::single(Condition::new(
            "Transaction.Time".to_string(),
            Operator::Contains,
            Value::String("02:".to_string()),
        )),
        vec![
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String(
                    "TIME ALERT: Late night transaction".to_string(),
                )],
            },
            ActionType::MethodCall {
                object: "Alert".to_string(),
                method: "setFraudScore".to_string(),
                args: vec![Value::Number(20.0)],
            },
        ],
    )
    .with_salience(6);

    // Rule 4: High Risk Merchant Category
    let high_risk_merchant_rule = Rule::new(
        "HighRiskMerchantAlert".to_string(),
        ConditionGroup::single(Condition::new(
            "Transaction.MerchantCategory".to_string(),
            Operator::Equal,
            Value::String("CASINO".to_string()),
        )),
        vec![
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String(
                    "MERCHANT ALERT: High-risk merchant category".to_string(),
                )],
            },
            ActionType::MethodCall {
                object: "Alert".to_string(),
                method: "setFraudScore".to_string(),
                args: vec![Value::Number(40.0)],
            },
        ],
    )
    .with_salience(7);

    // Rule 5: Critical Fraud Score Alert
    let critical_fraud_rule = Rule::new(
        "CriticalFraudAlert".to_string(),
        ConditionGroup::single(Condition::new(
            "Alert.FraudScore".to_string(),
            Operator::GreaterThanOrEqual,
            Value::Number(70.0),
        )),
        vec![
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String(
                    "🚨 CRITICAL FRAUD ALERT! Blocking transaction!".to_string(),
                )],
            },
            ActionType::Set {
                field: "Alert.Status".to_string(),
                value: Value::String("BLOCKED".to_string()),
            },
            ActionType::Call {
                function: "format".to_string(),
                args: vec![
                    Value::String("Transaction #{0} BLOCKED - Fraud Score: {1}".to_string()),
                    Value::String("TX123456".to_string()),
                    Value::String("Alert.FraudScore".to_string()),
                ],
            },
        ],
    )
    .with_salience(15);

    // Rule 6: Account Insufficient Funds
    let insufficient_funds_rule = Rule::new(
        "InsufficientFundsAlert".to_string(),
        ConditionGroup::single(Condition::new(
            "Account.Balance".to_string(),
            Operator::LessThan,
            Value::String("Transaction.Amount".to_string()),
        )),
        vec![
            ActionType::Call {
                function: "log".to_string(),
                args: vec![Value::String(
                    "💰 INSUFFICIENT FUNDS: Transaction declined".to_string(),
                )],
            },
            ActionType::Set {
                field: "Alert.Status".to_string(),
                value: Value::String("DECLINED".to_string()),
            },
        ],
    )
    .with_salience(20); // Highest priority

    // Add rules to knowledge base
    let _ = kb.add_rule(high_amount_rule);
    let _ = kb.add_rule(foreign_location_rule);
    let _ = kb.add_rule(late_night_rule);
    let _ = kb.add_rule(high_risk_merchant_rule);
    let _ = kb.add_rule(critical_fraud_rule);
    let _ = kb.add_rule(insufficient_funds_rule);

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

    println!("🔍 Running fraud detection analysis...");
    let result = engine.execute(&facts)?;

    println!("\n📊 Fraud Detection 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 analysis:");
    if let Some(transaction) = facts.get("Transaction") {
        println!("   Transaction = {transaction:?}");
    }
    if let Some(account) = facts.get("Account") {
        println!("   Account = {account:?}");
    }
    if let Some(alert) = facts.get("Alert") {
        println!("   Alert = {alert:?}");
    }

    println!("\n🎯 Fraud Detection Rules Demonstrated:");
    println!("   🚨 High Amount Transactions");
    println!("   🌍 Foreign Location Detection");
    println!("   🌙 Late Night Activity");
    println!("   🎰 High-Risk Merchant Categories");
    println!("   ⚠️ Critical Fraud Score Alerts");
    println!("   💰 Insufficient Funds Checks");

    Ok(())
}

examples/ecommerce.rs (line 103)

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 with_priority(self, priority: i32) -> Self

Set the priority of the rule (alias for salience)

pub fn matches(&self, facts: &HashMap<String, Value>) -> bool

Check if this rule matches the given facts

Trait Implementations

impl Clone for Rule

fn clone(&self) -> Rule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Rule

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

Formats the value using the given formatter.