Struct NamedRule 

pub struct NamedRule<F: Clone> { /* private fields */ }

We can create a rule using this struct and pass it into our list of rules directly, For debugging and tracing, it is helpful to see rules by a meaningful name. or we can make use of the named_rule macro (see [tree-morph-macros]).

This struct and macro is for the short form way of defining named rules. You can change the name of the rule by implementing the Rule trait as well.

use tree_morph::prelude::*;
use tree_morph_macros::named_rule;
use uniplate::Uniplate;

#[derive(Debug, Clone, PartialEq, Eq, Uniplate)]
#[uniplate()]
enum Expr {
  // Snip
}

struct Meta;

#[named_rule("CustomName")]
fn my_rule(_: &mut Commands<Expr, Meta>, expr: &Expr, _: &Meta) -> Option<Expr> {
   /// rule implementation
}

This macro will return a helper function called my_rule which returns the NamedRule for us to use. We can add this to our list of rules with vec![my_rule].

If a name is not specified, the functions name will be it’s identifier.

Implementations

impl<F: Clone> NamedRule<F>

pub const fn new(name: &'static str, function: F) -> Self

Create a Rule with a specified name.

Trait Implementations

impl<F: Clone + Clone> Clone for NamedRule<F>

fn clone(&self) -> NamedRule<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, M, F> Rule<T, M> for NamedRule<F>

where T: Uniplate, F: Fn(&mut Commands<T, M>, &T, &M) -> Option<T> + Clone,

fn apply( &self, commands: &mut Commands<T, M>, subtree: &T, meta: &M, ) -> Option<T>

Applies the rule to the given subtree and returns the result if applicable.

fn name(&self) -> &str

Return the name of the rule, will default to anonymous if not specified.

fn applicable_to(&self) -> Option<Vec<usize>>

None -> Rule applies to all nodes Some(ids) -> Rule only applies to nodes with these discriminant ids

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.