Struct EngineBuilder 

pub struct EngineBuilder<T, M, R, C>
where
    T: Uniplate + Send + Sync,
    R: Rule<T, M> + Clone,
    C: RewriteCache<T>,
{ /* private fields */ }

A builder type for constructing and configuring Engine instances.

Implementations

impl<T, M, R> EngineBuilder<T, M, R, NoCache>

where T: Uniplate + Send + Sync, R: Rule<T, M> + Clone,

pub fn new() -> Self

Creates a new builder instance with the default select_first selector.

impl<T, M, R, C> EngineBuilder<T, M, R, C>

where T: Uniplate + Send + Sync, R: Rule<T, M> + Clone, C: RewriteCache<T>,

pub fn build(self) -> Engine<T, M, R, C>

Consumes the builder and returns the constructed Engine instance.

pub fn add_rule_group(self, rules: Vec<R>) -> Self

Adds a collection of rules with the same priority.

These rules will have a lower priority than previously added groups.

pub fn add_rule(self, rule: R) -> Self

Adds a single rule in a group by itself.

This is a special case of add_rule_group.

pub fn append_rule_groups(self, groups: Vec<Vec<R>>) -> Self

Adds a collection of rule groups to the existing one.

Rule groups maintain the same order and will be lower priority than existing groups.

pub fn add_before_up(self, handler: fn(&T, &mut M)) -> Self

Register an event handler to be called before moving $dir in the tree.

pub fn add_after_up(self, handler: fn(&T, &mut M)) -> Self

Register an event handler to be called after moving $dir one node in the tree.

pub fn add_before_down(self, handler: fn(&T, &mut M)) -> Self

Register an event handler to be called before moving $dir in the tree.

pub fn add_after_down(self, handler: fn(&T, &mut M)) -> Self

Register an event handler to be called after moving $dir one node in the tree.

pub fn add_before_right(self, handler: fn(&T, &mut M)) -> Self

Register an event handler to be called before moving $dir in the tree.

pub fn add_after_right(self, handler: fn(&T, &mut M)) -> Self

Register an event handler to be called after moving $dir one node in the tree.

pub fn add_before_rule(self, handler: fn(&T, &mut M, &R)) -> Self

Register an event handler to be called before attempting a rule

pub fn add_after_rule(self, handler: fn(&T, &mut M, &R, bool)) -> Self

Register an event handler to be called after attempting a rule The boolean signifies whether the rule is applicable

pub fn add_after_apply(self, handler: fn(&T, &mut M, &R)) -> Self

Register an event handler to be called after applying a rule

pub fn add_on_cache_hit(self, handler: fn(&T, &mut M)) -> Self

Register an event handler to be called on a cache hit

pub fn add_on_cache_miss(self, handler: fn(&T, &mut M)) -> Self

Register an event handler to be called on a cache miss

pub fn set_selector(self, selector: SelectorFn<T, M, R>) -> Self

Sets the selector function to be used when multiple rules are applicable to the same node.

See the morph method of the Engine type for more information.

pub fn add_cacher<Cache: RewriteCache<T>>( self, cacher: Cache, ) -> EngineBuilder<T, M, R, Cache>

Adds caching support to tree-morph.

Recommended to use [HashMapCache] as it has a concrete implementation

pub fn set_parallel(self, parallel: bool) -> Self

Enables or disables parallel rule checking via Rayon.

When enabled, all rules are tested in parallel using par_iter. Defaults to false.

pub fn set_discriminant_fn( self, discriminant_fn: Option<fn(&T) -> usize>, ) -> Self

Sets the discriminant function used for rule prefiltering.

When Some(f) is provided, f is called on each node to compute a unique usize id, which is used to skip rules that do not apply to that node type. When None, prefiltering is disabled and all rules are tried on every node.

pub fn set_fixedpoint(self, fixedpoint: bool) -> Self

Fixed-point application: after a rule fires, re-apply rules to the transformed node until no more rules match, before continuing traversal.

pub fn add_down_predicate(self, predicate: fn(&T) -> bool) -> Self

Adds a predicate that controls whether the engine descends into a node’s children.

Trait Implementations

impl<T, M, R> Default for EngineBuilder<T, M, R, NoCache>

where T: Uniplate + Send + Sync, R: Rule<T, M> + Clone,

fn default() -> Self

Returns the “default value” for a type.

impl<T, M, R, C> From<EngineBuilder<T, M, R, C>> for Engine<T, M, R, C>

where T: Uniplate + Send + Sync, R: Rule<T, M> + Clone, C: RewriteCache<T>,

fn from(val: EngineBuilder<T, M, R, C>) -> Self

Converts to this type from the input type.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.