Struct GenericRule 

pub struct GenericRule<Head, Leaf>
where
    Head: Clone + Display,
    Leaf: Clone + PartialEq + Eq + Display + Hash,
{
    pub span: Span,
    pub head: GenericActions<Head, Leaf>,
    pub body: Vec<GenericFact<Head, Leaf>>,
    pub name: String,
    pub ruleset: String,
    pub eval_mode: RuleEvalMode,
    pub no_decomp: bool,
    pub include_subsumed: bool,
}

Fields

span: Span

head: GenericActions<Head, Leaf>

body: Vec<GenericFact<Head, Leaf>>

name: String

A globally unique name for this rule in the EGraph.

ruleset: String

The ruleset this rule belongs to. Defaults to "".

eval_mode: RuleEvalMode

How this rule is evaluated; set by :naive / :unsafe-seminaive.

no_decomp: bool

If true, this rule skips tree-decomposition during query planning and evaluate rules as a single-bag (without decomposing it into smaller queries). Set via the :no-decomp rule option.

include_subsumed: bool

If true, table atoms in this rule match subsumed rows as well as live rows. This is intended for internal maintenance rules, not ordinary user rewrites.

Implementations

impl<Head, Leaf> GenericRule<Head, Leaf>

where Head: Clone + Display, Leaf: Clone + PartialEq + Eq + Display + Hash,

pub fn visit_exprs( self, f: &mut impl FnMut(GenericExpr<Head, Leaf>) -> GenericExpr<Head, Leaf>, ) -> Self

Applies f to every expression that appears in the rule body or head.

pub fn visit_actions( self, f: &mut impl FnMut(GenericAction<Head, Leaf>) -> GenericAction<Head, Leaf>, ) -> Self

Applies f to each action in the rule head, leaving the body unchanged.

pub fn map_symbols<Head2, Leaf2>( self, head: &mut impl FnMut(Head) -> Head2, leaf: &mut impl FnMut(Leaf) -> Leaf2, ) -> GenericRule<Head2, Leaf2>

where Head2: Clone + Display, Leaf2: Clone + PartialEq + Eq + Display + Hash,

Applies the provided head and leaf mappings to every symbol that appears in the rule.

pub fn make_unresolved(self) -> GenericRule<String, String>

Converts the rule into its unresolved representation by formatting heads and leaves.

Trait Implementations

impl<Head, Leaf> Clone for GenericRule<Head, Leaf>

where Head: Clone + Display + Clone, Leaf: Clone + PartialEq + Eq + Display + Hash + Clone,

fn clone(&self) -> GenericRule<Head, Leaf>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Head, Leaf> Debug for GenericRule<Head, Leaf>

where Head: Clone + Display + Debug, Leaf: Clone + PartialEq + Eq + Display + Hash + Debug,

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

Formats the value using the given formatter.

impl<Head, Leaf> Display for GenericRule<Head, Leaf>

where Head: Clone + Display, Leaf: Clone + PartialEq + Eq + Display + Hash,

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

Formats the value using the given formatter.

impl<Head, Leaf> Hash for GenericRule<Head, Leaf>

where Head: Clone + Display + Hash, Leaf: Clone + PartialEq + Eq + Display + Hash + Hash,

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<Head, Leaf> PartialEq for GenericRule<Head, Leaf>

where Head: Clone + Display + PartialEq, Leaf: Clone + PartialEq + Eq + Display + Hash + PartialEq,

fn eq(&self, other: &GenericRule<Head, Leaf>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Head, Leaf> Eq for GenericRule<Head, Leaf>

where Head: Clone + Display + Eq, Leaf: Clone + PartialEq + Eq + Display + Hash + Eq,

impl<Head, Leaf> StructuralPartialEq for GenericRule<Head, Leaf>

where Head: Clone + Display, Leaf: Clone + PartialEq + Eq + Display + Hash,