Enum BooleanExpr 

pub enum BooleanExpr<Var> {
    False,
    True,
    Var(Var),
    Neg(Box<Self>),
    And(Box<Self>, Box<Self>),
    Or(Box<Self>, Box<Self>),
    Xor(Box<Self>, Box<Self>),
}

Boolean expression.

Variants

False

Boolean value False.

True

Boolean value True.

Var(Var)

Variable in an expression.

Neg(Box<Self>)

Unary negation of an expression.

And(Box<Self>, Box<Self>)

Binary Boolean AND of two expressions.

Or(Box<Self>, Box<Self>)

Binary Boolean OR of two expressions.

Xor(Box<Self>, Box<Self>)

Binary Boolean XOR of two expressions.

Implementations

impl<V> BooleanExpr<V>

pub fn eval<B>(&self, value_fn: &impl Fn(&V) -> B) -> B

where B: Not<Output = B> + BitAnd<Output = B> + BitOr<Output = B> + BitXor<Output = B> + Default,

Evaluate the expression. Variable are passed with the callback function value_fn. The type B usually represents Boolean logic values. For example bool can be used.

Note that B::default() is required to return the Boolean value false.

Example

use liberty_io::boolean::*;

// Create a simple boolean expression.
let a = BooleanExpr::Var(0);
let b = BooleanExpr::Var(1);
let expr = a ^ b;

let values = [true, false];
assert_eq!(expr.eval(&|var| values[*var]), true);

let values = [true, true];
assert_eq!(expr.eval(&|var| values[*var]), false);

pub fn substitute_variable_names<V2>( &self, substitution: &impl Fn(&V) -> V2, ) -> BooleanExpr<V2>

Substitute variables in the expression. Can also be used to change the data-type of the variables.

Example

use liberty_io::boolean::*;

// Create a simple boolean expression.
let a = BooleanExpr::Var(0);
let b = BooleanExpr::Var(1);
let expr = a & b;

// Define the variable mapping used for the substitution.
let substitution = |var: &usize| -> String {
   match var {
      0 => "a".into(),
      1 => "b".into(),
      _ => panic!("no such variable")
   }
};

// Apply the substitution.
let substituted = expr.substitute_variable_names(&substitution);

pub fn substitute_variables<V2>( &self, substitution: &impl Fn(&V) -> BooleanExpr<V2>, ) -> BooleanExpr<V2>

Substitute all variables by an expression.

Example

Replace some variables by a constant:

use liberty_io::boolean::*;

// Create a simple boolean expression.
let a = BooleanExpr::Var("a");
let b = BooleanExpr::Var("b");
let expr = a & b;

// Define the variable mapping used for the substitution.
let substitution = |&var: &&'static str| -> BooleanExpr<&'static str> {
   match var {
      "a" => BooleanExpr::False, // Replace "a".
      var => BooleanExpr::Var(var) // Don't do anything else for all other variables.
   }
};

// Apply the substitution.
let substituted = expr.substitute_variables(&substitution);

Trait Implementations

impl<V> Add for BooleanExpr<V>

type Output = BooleanExpr<V>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<V> BitAnd for BooleanExpr<V>

type Output = BooleanExpr<V>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<V> BitOr for BooleanExpr<V>

type Output = BooleanExpr<V>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<V> BitXor for BooleanExpr<V>

type Output = BooleanExpr<V>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<Var: Clone> Clone for BooleanExpr<Var>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Var: Debug> Debug for BooleanExpr<Var>

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

Formats the value using the given formatter.

impl<V> Display for BooleanExpr<V>

where V: Display,

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

Formats the value using the given formatter.

impl<Var: Eq> Eq for BooleanExpr<Var>

impl<V> From<bool> for BooleanExpr<V>

fn from(value: bool) -> Self

Converts to this type from the input type.

impl<Var: Hash> Hash for BooleanExpr<Var>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<V> Mul for BooleanExpr<V>

type Output = BooleanExpr<V>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<V> Not for BooleanExpr<V>

type Output = BooleanExpr<V>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation using logical or bitwise negation.

impl<Var: PartialEq> PartialEq for BooleanExpr<Var>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<Var: PartialEq> StructuralPartialEq for BooleanExpr<Var>