Crate rust_rule_engine 

Rust Rule Engine - GRL Edition

A high-performance rule engine for Rust with GRL (Grule Rule Language) support, featuring method calls, object interactions, and complex condition evaluation.

Features

• 🔥 GRL Support: Full Grule-compatible syntax
• 🎯 Method Calls: $Object.method(args) and property access
• 📊 Knowledge Base: Centralized rule management with salience
• 💾 Working Memory: Facts system for complex object interactions
• ⚡ High Performance: Optimized execution with cycle detection
• 🔄 Arithmetic: Complex calculations in conditions and actions
• 🛡️ Type Safety: Rust’s type system ensures runtime safety

Quick Start

use rust_rule_engine::*;

fn main() -> Result<()> {
    // Create Knowledge Base
    let kb = KnowledgeBase::new("Demo");
     
    // Define GRL rule
    let rule = r#"
    rule "AgeCheck" salience 10 {
        when
            User.Age >= 18 && User.Country == "US"
        then
            User.IsAdult = true;
            User.DiscountRate = 0.10;
    }
    "#;
     
    // Parse and add rule
    let rules = GRLParser::parse_rules(rule)?;
    let parsed_rule = rules.into_iter().next().unwrap();
    kb.add_rule(parsed_rule)?;
     
    // Create engine
    let mut engine = RustRuleEngine::new(kb);
     
    // Create facts
    let facts = Facts::new();
    let user = FactHelper::create_user("john", 25, "john@email.com", "US", false);
    facts.add_value("User", user)?;
     
    // Execute rules
    let result = engine.execute(&facts)?;
    println!("Rules fired: {}", result.rules_fired);
     
    Ok(())
}

Advanced Features

Method Calls and Object Interactions

let speedup_rule = r#"
rule "SpeedUp" salience 10 {
    when
        $TestCar : TestCarClass( speedUp == true && speed < maxSpeed )
    then
        $TestCar.setSpeed($TestCar.Speed + $TestCar.SpeedIncrement);
        update($TestCar);
}
"#;

E-commerce Rules

let discount_rule = r#"
rule "PremiumDiscount" salience 20 {
    when
        Customer.Membership == "premium" && Order.Total > 100
    then
        Order.DiscountRate = 0.15;
        Order.FreeShipping = true;
}
"#;

Core Components

• KnowledgeBase: Manages collections of rules with metadata
• Facts: Working memory for data objects and rule evaluation
• RustRuleEngine: Executes rules with configurable options
• GRLParser: Parses Grule Rule Language syntax
• FactHelper: Utility functions for creating data objects
• Value: Flexible data type system supporting objects, arrays, primitives

Re-exports

pub use errors::Result;

pub use errors::RuleEngineError;

pub use types::ActionType;

pub use types::LogicalOperator;

pub use types::Operator;

pub use types::Value;

pub use engine::engine::EngineConfig;

pub use engine::engine::GruleExecutionResult;

pub use engine::engine::RustRuleEngine;

pub use engine::facts::FactHelper;

pub use engine::facts::Facts;

pub use engine::knowledge_base::KnowledgeBase;

pub use engine::rule::Condition;

pub use engine::rule::ConditionGroup;

pub use engine::rule::Rule;

pub use parser::grl::GRLParser;

Modules

engine

Rule execution engine and related components

errors

Error types and result handling

parser

Rule parsing and language support

streaming

Streaming rule engine for real-time event processing Rule Streaming Engine - Real-time Event Processing

types

Core type definitions for values, operators, and actions

Macros

impl_fact

Macro to implement Fact trait easily

Structs

RuleEngineBuilder

Builder pattern for creating a RustRuleEngine with various configurations