expert-rs

A cache friendly and type safe expert/business rules system written in Rust.

Usage

Don't. It's not even Alpha quality, yet.

Eventually you'll be able to add a dependency ala

toml [dependencies] expert = "0.10"

And then write code similar to

```rust

[macro_use]

extern crate expert;

// A fact type

[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Fact)]

pub struct Fact1 { id: usize, len: usize, }

// Another fact type

[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Fact)]

pub struct Fact2 { id: usize, height: usize }

mod example { // Creates a new expert system specifically for Fact1 and Fact2 expert!(Example; [Fact1, Fact2]); }

pub fn main() { use example::*;

// Create a custom rule builder
let mut builder = ExampleBuilder::new();
builder.
    // Add a new rule named "rule"
    rule("rule")
        // When a Fact1 is inserted with self.id == 2 and self.len < 32
        .when<Fact1>().eq("id", 2usize).lt("len", 32usize)
        // And when a Fact2 is inserted with sef.id ==3 and self.height >= 64
        .when<Fact2>().eq("id", 17usize).gte("height", 64usize)
    .then()
        // Add a new Fact1{id: 3, len: 20} to be available for return
        .ret<Fact1>().field("id", 3usize).field("len", 20usize)
    .end();

// Create a knowledge base to hold the read-only, in-memory representation of all of the rules let example_base = builder.build();

// Create a knowledge session/rule runtime let mut examplesession = examplebase.new_session();

let afact = Fact1{id: 2usize, len: 31usize}; let anotherfact = Fact2{id: 3usize, height: 60usize};

// Insert the facts examplesession.insert(afact); examplesession.insert(anotherfact);

// Resolve the rule consequences example_session.resolve();

let fact1returns: &[Fact1] = ::getreturns(&examplesession); assert(fact1returns.len() == 1); let fact1ret = fact1returns.get(0).unwrap(); assert(fact1ret.id == 3); assert(fact1ret.len == 20); }

```

Features

• The code compiles!
• Alpha (fact analysis) nodes!
• Statement Builder!

In-Progress

• Rule Builder!
• KnowledgeBase Builder!
• Alpha, Beta node compilation and layout!
  • Networks represented as a set of arrays!
  • Alpha network ordered from most depended on nodes to least!
  • Beta network ordered from least depended to most!
• Chaining!
  • Forwards!
  • Backwards! (w/ Iterators)
• Returns, Insert within rule resolution
• All of those sweet, sweet macros

Not In-Progress (everything else!)

• Variables
  • Fact
  • Field
• Complex logic ((this AND this AND NOT that) OR other)
• DSL
• Fast rule compilation times
• Rule optimizations
• Rule sanity checks
• In-place fact modification

Why?

• Expert/Business Rules Systems are still in use in a variety of industries
• I wanted to understand how the algorithms worked
• I wanted to push my software development expertise
• I wanted to see if I could write it without pointers, fat or otherwise
• It's hard

License

This project is licensed under either of

• Apache License, Version 2.0, (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Serde by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.