Struct Fold 

pub struct Fold<'a, T, U> {
    pub step: &'a mut dyn FnMut(T, FoldNode<'_>) -> T,
    pub initial: T,
    pub extract: &'a dyn Fn(T, Option<(U, U)>) -> U,
}

Folds in the style of foldl on hackage. This performs specialized folds over FoldNode representations. With a (currently non-existent) composition, one can perform multiple folds in a single walk of the BDD.

See Fold::mut_fold’s documentation for an example of how to write this style of fold.

Fields

step: &'a mut dyn FnMut(T, FoldNode<'_>) -> T

FnMut step which takes in an aggregation T and a node representation FoldNode.

initial: T

The initial value for the aggregation.

extract: &'a dyn Fn(T, Option<(U, U)>) -> U

How to extract the final value U from a node. If a node has children, provide the final outputs of their values as a tuple.

Implementations

impl<'a, T: Clone, U> Fold<'a, T, U>

pub fn new( step: &'a mut dyn FnMut(T, FoldNode<'_>) -> T, initial: T, extract: &'a dyn Fn(T, Option<(U, U)>) -> U, ) -> Fold<'a, T, U>

Construct a new Fold.

pub fn mut_fold(&mut self, bdd: &BddPtr<'_>) -> U

A mutable fold. An example of how to use this fold can be seen by collecting all VarLabels in the sub-tree referenced by a given BddPtr:

use rsdd::repr::VarLabel;
use rsdd::repr::BddPtr;
use rsdd::repr::Fold;

pub fn variables(bdd: BddPtr) -> Vec<VarLabel> {
    Fold::new(
        &mut |vs: Vec<Option<VarLabel>>, bdd| {
            let mut vs = vs;
            vs.push(bdd.node.var_safe());
            vs
        },
        vec![],
        &|ret, lo_hi| match lo_hi {
            None => ret,
            Some((lo, hi)) => {
                let mut v = ret;
                v.extend(lo);
                v.extend(hi);
                v
            }
        },
    )
    .mut_fold(&bdd)
    .into_iter()
    .flatten()
    .collect()
}