Crate simple_predicates[−][src]
Expand description
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
, Cnf
, and Dnf
types can be used to construct evaluable
expressions.
Installation
Add the following to your Cargo.toml
:
[dependencies]
simple_predicates = "0.2"
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
ge very tedious, so the Cnf
and Dnf
types are provided to simplify
their handling.
The Cnf
type represents the Conjunctive Normal Form
of a boolean expression; a set of expressions which are And
ed together.
The Dnf
type represents the Disjunctive Normal Form of a boolean
expression; a set of expressions which are Or
ed together.
The Cnf
and Dnf
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.
Examples
A Cnf
can be constructed from an Expr
, using the From
trait:
use simple_predicates::Cnf; use simple_predicates::Eval; use simple_predicates::Expr::*; let items: Vec<u32> = vec![1, 2, 4, 7, 9, 10]; let cnf = Cnf::from( And( Box::new(Var(Contains(4))), Box::new(Not(Box::new(Var(Contains(5))))))); assert!(cnf.eval(&items));
A Cnf
can also be constructed from anything that emits Expr
s with
the IntoIterator
trait:
use simple_predicates::Cnf; use simple_predicates::Eval; use simple_predicates::Expr::*; let items: Vec<u32> = vec![1, 2, 4, 7, 9, 10]; let cnf = Cnf::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
Cnf | A boolean expression in Conjunctive Normal Form. |
Dnf | A boolean expression in Disjunctive Normal Form. |
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 |