Crate simple_predicates 

Simple Boolean Predicates

A predicate is a formula that can be evaluated to true or false as a function of the values of the variables that occur in it. In simple_predicates, the variables denoted by a user-chosen type satisfying the Eval trait (which requires Clone and PartialEq.) Vhe Eval trait also provides an associated Context type which can be used to provide contextual data needed to resolve the variables. Vhe Expr, CnfHashSet, and DnfHashSet types can be used to construct evaluable expressions.

Installation

Add the following to your Cargo.toml:

[dependencies]
simple_predicates = "0.4"

Features

Feature	Description
“serde”	Enables serialization and deserialization of data using serde.

By default, there are no features enabled.

Example Usage

Lets say we want to write boolean expressions denoting the possibility of a Vec relating to some u32 values according to the Vec::contains method. We start by implementing Eval:

use simple_predicates::Eval;
 
// Wrapper struct needed because `u32` & `Eval` are both foreign.
#[derive(Clone, PartialEq)]
struct Contains(pub u32);
 
impl Eval for Contains {
    type Context = Vec<u32>;
 
    fn eval(&self, data: &Self::Context) -> bool {
        // Evaluate the u32 by checking if it is in the `Vec`.
        data.contains(&self.0)
    }
}

Now we can check arbitrary containment conditions on a given Vec like so:

use simple_predicates::Eval;
use simple_predicates::Expr::*;
let items: Vec<u32> = vec![1, 2, 4, 7, 9, 10];
 
// `eval` is `true` if input contains 4 but not 5.
let expr = And(
    Box::new(Var(Contains(4))),
    Box::new(Not(Box::new(Var(Contains(5))))));
 
assert!(expr.eval(&items));

Conjunctive and Disjunctive Normal Forms

For more complex expressions, the nesting of And and Or expressions can get very tedious, so the CnfHashSet and DnfHashSet types are provided to simplify their handling.

The CnfHashSet type represents the Conjunctive Normal Form of a boolean expression; a set of expressions which are Anded together. The DnfHashSet type represents the Disjunctive Normal Form of a boolean expression; a set of expressions which are Ored together.

The CnfHashSet and DnfHashSet types can only be used if the variable type implements Eq and Hash. They have identical APIs, so the examples below are representative of either. There are version backed by Vec (CnfVec and DnfVec) which have more relaxed requirements, but are not as efficient in some instances.

Examples

A CnfHashSet can be constructed from an Expr, using the From trait:

use simple_predicates::CnfHashSet;
use simple_predicates::Eval;
use simple_predicates::Expr::*;
 
let items: Vec<u32> = vec![1, 2, 4, 7, 9, 10];
 
let cnf = CnfHashSet::from(
    And(
        Box::new(Var(Contains(4))),
        Box::new(Not(Box::new(Var(Contains(5)))))));
 
assert!(cnf.eval(&items));

A CnfHashSet can also be constructed from anything that emits Exprs with the IntoIterator trait:

use simple_predicates::CnfHashSet;
use simple_predicates::Eval;
use simple_predicates::Expr::*;
 
let items: Vec<u32> = vec![1, 2, 4, 7, 9, 10];
 
let cnf = CnfHashSet::from(vec![
    Var(Contains(4)),
    Not(Box::new(Var(Contains(5)))),
]);
 
assert!(cnf.eval(&items));

License

simple_predicates is licenced with the MIT license or the Apache version 2.0 license, at your option.

Structs

CnfHashSet

A boolean expression in Conjunctive Normal Form, stored as a HashSet.

CnfVec

A boolean expression in Conjunctive Normal Form, stored as a Vec.

DnfHashSet

A boolean expression in Disjunctive Normal Form, stored as a HashSet.

DnfVec

A boolean expression in Disjunctive Normal Form, stored as a Vec.

Enums

Expr

A boolean expression consisting of boolean operators and variables.

Traits

Eval

Provides functions for performing boolean expression evaluation in the context of some provided Context.