Removed a copious amount of premature Rc-s

src/rule/matcher_vectree/any_match.rs

@@ -1,12 +1,12 @@
 use super::scal_match::scalv_match;
 use super::shared::AnyMatcher;
 use super::vec_match::vec_match;
-use crate::ast::Expr;
+use crate::rule::matcher::RuleExpr;
 use crate::rule::state::State;
 
 pub fn any_match<'a>(
   matcher: &AnyMatcher,
-  seq: &'a [Expr],
+  seq: &'a [RuleExpr],
 ) -> Option<State<'a>> {
   match matcher {
     AnyMatcher::Scalar(scalv) => scalv_match(scalv, seq),

src/rule/matcher_vectree/build.rs

@@ -1,16 +1,18 @@
 use itertools::Itertools;
 
 use super::shared::{AnyMatcher, ScalMatcher, VecMatcher};
-use crate::ast::{Clause, Expr, PHClass, Placeholder};
+use crate::ast::{Clause, PHClass, Placeholder};
 use crate::interner::Tok;
+use crate::rule::matcher::RuleExpr;
 use crate::rule::vec_attrs::vec_attrs;
 use crate::utils::Side;
 
-pub type MaxVecSplit<'a> = (&'a [Expr], (Tok<String>, u64, bool), &'a [Expr]);
+pub type MaxVecSplit<'a> =
+  (&'a [RuleExpr], (Tok<String>, u64, bool), &'a [RuleExpr]);
 
 /// Derive the details of the central vectorial and the two sides from a
 /// slice of Expr's
-fn split_at_max_vec(pattern: &[Expr]) -> Option<MaxVecSplit> {
+fn split_at_max_vec(pattern: &[RuleExpr]) -> Option<MaxVecSplit> {
   let rngidx = pattern.iter().position_max_by_key(|expr| {
     vec_attrs(expr).map(|attrs| attrs.1 as i64).unwrap_or(-1)
   })?;
@@ -21,11 +23,11 @@ fn split_at_max_vec(pattern: &[Expr]) -> Option<MaxVecSplit> {
   vec_attrs(placeh).map(|attrs| (left, attrs, right))
 }
 
-fn scal_cnt<'a>(iter: impl Iterator<Item = &'a Expr>) -> usize {
+fn scal_cnt<'a>(iter: impl Iterator<Item = &'a RuleExpr>) -> usize {
   iter.take_while(|expr| vec_attrs(expr).is_none()).count()
 }
 
-pub fn mk_any(pattern: &[Expr]) -> AnyMatcher {
+pub fn mk_any(pattern: &[RuleExpr]) -> AnyMatcher {
   let left_split = scal_cnt(pattern.iter());
   if pattern.len() <= left_split {
     return AnyMatcher::Scalar(mk_scalv(pattern));
@@ -41,12 +43,12 @@ pub fn mk_any(pattern: &[Expr]) -> AnyMatcher {
 }
 
 /// Pattern MUST NOT contain vectorial placeholders
-fn mk_scalv(pattern: &[Expr]) -> Vec<ScalMatcher> {
+fn mk_scalv(pattern: &[RuleExpr]) -> Vec<ScalMatcher> {
   pattern.iter().map(mk_scalar).collect()
 }
 
 /// Pattern MUST start and end with a vectorial placeholder
-fn mk_vec(pattern: &[Expr]) -> VecMatcher {
+fn mk_vec(pattern: &[RuleExpr]) -> VecMatcher {
   debug_assert!(!pattern.is_empty(), "pattern cannot be empty");
   debug_assert!(
     pattern.first().map(vec_attrs).is_some(),
@@ -97,7 +99,7 @@ fn mk_vec(pattern: &[Expr]) -> VecMatcher {
 }
 
 /// Pattern MUST NOT be a vectorial placeholder
-fn mk_scalar(pattern: &Expr) -> ScalMatcher {
+fn mk_scalar(pattern: &RuleExpr) -> ScalMatcher {
   match &pattern.value {
     Clause::P(p) => ScalMatcher::P(p.clone()),
     Clause::Name(n) => ScalMatcher::Name(*n),

src/rule/matcher_vectree/scal_match.rs

@@ -1,11 +1,12 @@
 use super::any_match::any_match;
 use super::shared::ScalMatcher;
-use crate::ast::{Clause, Expr};
+use crate::ast::Clause;
+use crate::rule::matcher::RuleExpr;
 use crate::rule::state::{State, StateEntry};
 
 pub fn scal_match<'a>(
   matcher: &ScalMatcher,
-  expr: &'a Expr,
+  expr: &'a RuleExpr,
 ) -> Option<State<'a>> {
   match (matcher, &expr.value) {
     (ScalMatcher::P(p1), Clause::P(p2)) if p1 == p2 => Some(State::new()),
@@ -25,7 +26,7 @@ pub fn scal_match<'a>(
 
 pub fn scalv_match<'a>(
   matchers: &[ScalMatcher],
-  seq: &'a [Expr],
+  seq: &'a [RuleExpr],
 ) -> Option<State<'a>> {
   if seq.len() != matchers.len() {
     return None;

src/rule/matcher_vectree/shared.rs

@@ -3,12 +3,12 @@ use std::rc::Rc;
 
 use super::any_match::any_match;
 use super::build::mk_any;
-use crate::ast::Expr;
-use crate::interner::{InternedDisplay, Interner, Sym, Tok};
+use crate::interner::{InternedDisplay, Interner, Tok};
 use crate::representations::Primitive;
-use crate::rule::matcher::Matcher;
+use crate::rule::matcher::{Matcher, RuleExpr};
 use crate::rule::state::State;
 use crate::utils::{sym2string, unwrap_or, Side};
+use crate::Sym;
 
 pub enum ScalMatcher {
   P(Primitive),
@@ -54,11 +54,11 @@ pub enum AnyMatcher {
   Vec { left: Vec<ScalMatcher>, mid: VecMatcher, right: Vec<ScalMatcher> },
 }
 impl Matcher for AnyMatcher {
-  fn new(pattern: Rc<Vec<Expr>>) -> Self {
+  fn new(pattern: Rc<Vec<RuleExpr>>) -> Self {
     mk_any(&pattern)
   }
 
-  fn apply<'a>(&self, source: &'a [Expr]) -> Option<State<'a>> {
+  fn apply<'a>(&self, source: &'a [RuleExpr]) -> Option<State<'a>> {
     any_match(self, source)
   }
 }
@@ -183,11 +183,11 @@ impl InternedDisplay for AnyMatcher {
 /// vectorial placeholders and handles the scalars on leaves.
 pub struct VectreeMatcher(AnyMatcher);
 impl Matcher for VectreeMatcher {
-  fn new(pattern: Rc<Vec<Expr>>) -> Self {
+  fn new(pattern: Rc<Vec<RuleExpr>>) -> Self {
     Self(AnyMatcher::new(pattern))
   }
 
-  fn apply<'a>(&self, source: &'a [Expr]) -> Option<State<'a>> {
+  fn apply<'a>(&self, source: &'a [RuleExpr]) -> Option<State<'a>> {
     self.0.apply(source)
   }
 }

src/rule/matcher_vectree/vec_match.rs

@@ -4,13 +4,13 @@ use itertools::Itertools;
 
 use super::scal_match::scalv_match;
 use super::shared::VecMatcher;
-use crate::ast::Expr;
+use crate::rule::matcher::RuleExpr;
 use crate::rule::state::{State, StateEntry};
 use crate::utils::unwrap_or;
 
 pub fn vec_match<'a>(
   matcher: &VecMatcher,
-  seq: &'a [Expr],
+  seq: &'a [RuleExpr],
 ) -> Option<State<'a>> {
   match matcher {
     VecMatcher::Placeh { key, nonzero } => {