commit before easter break

orchid-std/src/macros/rule/any_match.rs

@@ -0,0 +1,30 @@
+use orchid_base::name::Sym;
+
+use super::scal_match::scalv_match;
+use super::shared::AnyMatcher;
+use super::state::MatchState;
+use super::vec_match::vec_match;
+use crate::macros::MacTree;
+
+#[must_use]
+pub fn any_match<'a>(
+	matcher: &AnyMatcher,
+	seq: &'a [MacTree],
+	save_loc: &impl Fn(Sym) -> bool,
+) -> Option<MatchState<'a>> {
+	match matcher {
+		AnyMatcher::Scalar(scalv) => scalv_match(scalv, seq, save_loc),
+		AnyMatcher::Vec { left, mid, right } => {
+			if seq.len() < left.len() + right.len() {
+				return None;
+			};
+			let left_split = left.len();
+			let right_split = seq.len() - right.len();
+			Some(
+				scalv_match(left, &seq[..left_split], save_loc)?
+					.combine(scalv_match(right, &seq[right_split..], save_loc)?)
+					.combine(vec_match(mid, &seq[left_split..right_split], save_loc)?),
+			)
+		},
+	}
+}

orchid-std/src/macros/rule/build.rs

@@ -0,0 +1,160 @@
+use itertools::Itertools;
+use orchid_api::PhKind;
+use orchid_base::interner::Tok;
+use orchid_base::side::Side;
+use orchid_base::tree::Ph;
+
+use super::shared::{AnyMatcher, ScalMatcher, VecMatcher};
+use super::vec_attrs::vec_attrs;
+use crate::macros::{MacTok, MacTree};
+
+pub type MaxVecSplit<'a> = (&'a [MacTree], (Tok<String>, u8, bool), &'a [MacTree]);
+
+/// Derive the details of the central vectorial and the two sides from a
+/// slice of Expr's
+#[must_use]
+fn split_at_max_vec(pattern: &[MacTree]) -> Option<MaxVecSplit> {
+	let rngidx = pattern
+		.iter()
+		.position_max_by_key(|expr| vec_attrs(expr).map(|attrs| attrs.1 as i64).unwrap_or(-1))?;
+	let (left, not_left) = pattern.split_at(rngidx);
+	let (placeh, right) =
+		not_left.split_first().expect("The index of the greatest element must be less than the length");
+	vec_attrs(placeh).map(|attrs| (left, attrs, right))
+}
+
+#[must_use]
+fn scal_cnt<'a>(iter: impl Iterator<Item = &'a MacTree>) -> usize {
+	iter.take_while(|expr| vec_attrs(expr).is_none()).count()
+}
+
+#[must_use]
+pub fn mk_any(pattern: &[MacTree]) -> AnyMatcher {
+	let left_split = scal_cnt(pattern.iter());
+	if pattern.len() <= left_split {
+		return AnyMatcher::Scalar(mk_scalv(pattern));
+	}
+	let (left, not_left) = pattern.split_at(left_split);
+	let right_split = not_left.len() - scal_cnt(pattern.iter().rev());
+	let (mid, right) = not_left.split_at(right_split);
+	AnyMatcher::Vec { left: mk_scalv(left), mid: mk_vec(mid), right: mk_scalv(right) }
+}
+
+/// Pattern MUST NOT contain vectorial placeholders
+#[must_use]
+fn mk_scalv(pattern: &[MacTree]) -> Vec<ScalMatcher> { pattern.iter().map(mk_scalar).collect() }
+
+/// Pattern MUST start and end with a vectorial placeholder
+#[must_use]
+pub fn mk_vec(pattern: &[MacTree]) -> VecMatcher {
+	debug_assert!(!pattern.is_empty(), "pattern cannot be empty");
+	debug_assert!(pattern.first().map(vec_attrs).is_some(), "pattern must start with a vectorial");
+	debug_assert!(pattern.last().map(vec_attrs).is_some(), "pattern must end with a vectorial");
+	let (left, (key, _, nonzero), right) = split_at_max_vec(pattern)
+		.expect("pattern must have vectorial placeholders at least at either end");
+	let r_sep_size = scal_cnt(right.iter());
+	let (r_sep, r_side) = right.split_at(r_sep_size);
+	let l_sep_size = scal_cnt(left.iter().rev());
+	let (l_side, l_sep) = left.split_at(left.len() - l_sep_size);
+	let main = VecMatcher::Placeh { key: key.clone(), nonzero };
+	match (left, right) {
+		(&[], &[]) => VecMatcher::Placeh { key, nonzero },
+		(&[], _) => VecMatcher::Scan {
+			direction: Side::Left,
+			left: Box::new(main),
+			sep: mk_scalv(r_sep),
+			right: Box::new(mk_vec(r_side)),
+		},
+		(_, &[]) => VecMatcher::Scan {
+			direction: Side::Right,
+			left: Box::new(mk_vec(l_side)),
+			sep: mk_scalv(l_sep),
+			right: Box::new(main),
+		},
+		(..) => {
+			let mut key_order =
+				l_side.iter().chain(r_side.iter()).filter_map(vec_attrs).collect::<Vec<_>>();
+			key_order.sort_by_key(|(_, prio, _)| -(*prio as i64));
+			VecMatcher::Middle {
+				left: Box::new(mk_vec(l_side)),
+				left_sep: mk_scalv(l_sep),
+				mid: Box::new(main),
+				right_sep: mk_scalv(r_sep),
+				right: Box::new(mk_vec(r_side)),
+				key_order: key_order.into_iter().map(|(n, ..)| n).collect(),
+			}
+		},
+	}
+}
+
+/// Pattern MUST NOT be a vectorial placeholder
+#[must_use]
+fn mk_scalar(pattern: &MacTree) -> ScalMatcher {
+	match &*pattern.tok {
+		MacTok::Name(n) => ScalMatcher::Name(n.clone()),
+		MacTok::Ph(Ph { name, kind }) => match kind {
+			PhKind::Vector { .. } => {
+				panic!("Scalar matcher cannot be built from vector pattern")
+			},
+			PhKind::Scalar => ScalMatcher::Placeh { key: name.clone() },
+		},
+		MacTok::S(c, body) => ScalMatcher::S(*c, Box::new(mk_any(body))),
+		MacTok::Lambda(arg, body) => ScalMatcher::Lambda(Box::new(mk_any(arg)), Box::new(mk_any(body))),
+		MacTok::Value(_) | MacTok::Slot => panic!("Only used for templating"),
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use std::rc::Rc;
+
+	use orchid_api::PhKind;
+	use orchid_base::interner::Interner;
+	use orchid_base::location::SourceRange;
+	use orchid_base::sym;
+	use orchid_base::tokens::Paren;
+	use orchid_base::tree::Ph;
+	use test_executors::spin_on;
+
+	use super::mk_any;
+	use crate::macros::{MacTok, MacTree};
+
+	#[test]
+	fn test_scan() {
+		spin_on(async {
+			let i = Interner::new_master();
+			let ex = |tok: MacTok| async {
+				MacTree { tok: Rc::new(tok), pos: SourceRange::mock(&i).await.pos() }
+			};
+			let pattern = vec![
+				ex(MacTok::Ph(Ph {
+					kind: PhKind::Vector { priority: 0, at_least_one: false },
+					name: i.i("::prefix").await,
+				}))
+				.await,
+				ex(MacTok::Name(sym!(prelude::do; i).await)).await,
+				ex(MacTok::S(Paren::Round, vec![
+					ex(MacTok::Ph(Ph {
+						kind: PhKind::Vector { priority: 0, at_least_one: false },
+						name: i.i("expr").await,
+					}))
+					.await,
+					ex(MacTok::Name(sym!(prelude::; ; i).await)).await,
+					ex(MacTok::Ph(Ph {
+						kind: PhKind::Vector { priority: 1, at_least_one: false },
+						name: i.i("rest").await,
+					}))
+					.await,
+				]))
+				.await,
+				ex(MacTok::Ph(Ph {
+					kind: PhKind::Vector { priority: 0, at_least_one: false },
+					name: i.i("::suffix").await,
+				}))
+				.await,
+			];
+			let matcher = mk_any(&pattern);
+			println!("{matcher}");
+		})
+	}
+}

orchid-std/src/macros/rule/matcher.rs

@@ -0,0 +1,87 @@
+use std::fmt;
+use std::rc::Rc;
+
+use itertools::Itertools;
+use orchid_api::PhKind;
+use orchid_base::interner::Interner;
+use orchid_base::location::Pos;
+use orchid_base::name::Sym;
+use orchid_base::tree::Ph;
+
+use super::any_match::any_match;
+use super::build::{mk_any, mk_vec};
+use super::shared::{AnyMatcher, VecMatcher};
+use super::state::{MatchState, StateEntry};
+use super::vec_attrs::vec_attrs;
+use super::vec_match::vec_match;
+use crate::macros::{MacTok, MacTree};
+
+pub fn first_is_vec(pattern: &[MacTree]) -> bool { vec_attrs(pattern.first().unwrap()).is_some() }
+pub fn last_is_vec(pattern: &[MacTree]) -> bool { vec_attrs(pattern.last().unwrap()).is_some() }
+
+pub struct NamedMatcher(AnyMatcher);
+impl NamedMatcher {
+	pub async fn new(pattern: &[MacTree], i: &Interner) -> Self {
+		assert!(
+			matches!(pattern.first().map(|tree| &*tree.tok), Some(MacTok::Name(_))),
+			"Named matchers must begin with a name"
+		);
+
+		match last_is_vec(pattern) {
+			true => Self(mk_any(pattern)),
+			false => {
+				let kind = PhKind::Vector { priority: 0, at_least_one: false };
+				let tok = MacTok::Ph(Ph { name: i.i("::after").await, kind });
+				let suffix = [MacTree { pos: Pos::None, tok: Rc::new(tok) }];
+				Self(mk_any(&pattern.iter().chain(&suffix).cloned().collect_vec()))
+			},
+		}
+	}
+	/// Also returns the tail, if any, which should be matched further
+	/// Note that due to how priod works below, the main usable information from
+	/// the tail is its length
+	pub async fn apply<'a>(
+		&self,
+		seq: &'a [MacTree],
+		i: &Interner,
+		save_loc: impl Fn(Sym) -> bool,
+	) -> Option<(MatchState<'a>, &'a [MacTree])> {
+		let mut state = any_match(&self.0, seq, &save_loc)?;
+		match state.remove(i.i("::after").await) {
+			Some(StateEntry::Scalar(_)) => panic!("::after can never be a scalar entry!"),
+			Some(StateEntry::Vec(v)) => Some((state, v)),
+			None => Some((state, &[][..])),
+		}
+	}
+}
+impl fmt::Display for NamedMatcher {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { self.0.fmt(f) }
+}
+impl fmt::Debug for NamedMatcher {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "NamedMatcher({self})") }
+}
+
+pub struct PriodMatcher(VecMatcher);
+impl PriodMatcher {
+	pub fn new(pattern: &[MacTree]) -> Self {
+		assert!(
+			pattern.first().and_then(vec_attrs).is_some() && pattern.last().and_then(vec_attrs).is_some(),
+			"Prioritized matchers must start and end with a vectorial",
+		);
+		Self(mk_vec(pattern))
+	}
+	/// tokens before the offset always match the prefix
+	pub fn apply<'a>(
+		&self,
+		seq: &'a [MacTree],
+		save_loc: impl Fn(Sym) -> bool,
+	) -> Option<MatchState<'a>> {
+		vec_match(&self.0, seq, &save_loc)
+	}
+}
+impl fmt::Display for PriodMatcher {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { self.0.fmt(f) }
+}
+impl fmt::Debug for PriodMatcher {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "PriodMatcher({self})") }
+}

orchid-std/src/macros/rule/mod.rs

@@ -0,0 +1,24 @@
+//! Optimized form of macro pattern that can be quickly tested against the AST.
+//!
+//! # Construction
+//!
+//! convert pattern into hierarchy of plain, scan, middle
+//! - plain: accept any sequence or any non-empty sequence
+//! - scan: a single scalar pattern moves LTR or RTL, submatchers on either side
+//! - middle: two scalar patterns walk over all permutations of matches while
+//!   getting progressively closer to each other
+//!
+//! # Application
+//!
+//! walk over the current matcher's valid options and poll the submatchers
+//! for each of them
+
+mod any_match;
+mod build;
+pub mod matcher;
+mod scal_match;
+pub mod shared;
+pub mod state;
+mod vec_attrs;
+mod vec_match;
+// pub mod matcher;

orchid-std/src/macros/rule/scal_match.rs

@@ -0,0 +1,43 @@
+use orchid_base::name::Sym;
+
+use super::any_match::any_match;
+use super::shared::ScalMatcher;
+use super::state::{MatchState, StateEntry};
+use crate::macros::{MacTok, MacTree};
+
+#[must_use]
+pub fn scal_match<'a>(
+	matcher: &ScalMatcher,
+	expr: &'a MacTree,
+	save_loc: &impl Fn(Sym) -> bool,
+) -> Option<MatchState<'a>> {
+	match (matcher, &*expr.tok) {
+		(ScalMatcher::Name(n1), MacTok::Name(n2)) if n1 == n2 => Some(match save_loc(n1.clone()) {
+			true => MatchState::from_name(n1.clone(), expr.pos.clone()),
+			false => MatchState::default(),
+		}),
+		(ScalMatcher::Placeh { key }, _) =>
+			Some(MatchState::from_ph(key.clone(), StateEntry::Scalar(expr))),
+		(ScalMatcher::S(c1, b_mat), MacTok::S(c2, body)) if c1 == c2 =>
+			any_match(b_mat, &body[..], save_loc),
+		(ScalMatcher::Lambda(arg_mat, b_mat), MacTok::Lambda(arg, body)) =>
+			Some(any_match(arg_mat, arg, save_loc)?.combine(any_match(b_mat, body, save_loc)?)),
+		_ => None,
+	}
+}
+
+#[must_use]
+pub fn scalv_match<'a>(
+	matchers: &[ScalMatcher],
+	seq: &'a [MacTree],
+	save_loc: &impl Fn(Sym) -> bool,
+) -> Option<MatchState<'a>> {
+	if seq.len() != matchers.len() {
+		return None;
+	}
+	let mut state = MatchState::default();
+	for (matcher, expr) in matchers.iter().zip(seq.iter()) {
+		state = state.combine(scal_match(matcher, expr, save_loc)?);
+	}
+	Some(state)
+}

orchid-std/src/macros/rule/shared.rs

@@ -0,0 +1,101 @@
+//! Datastructures for cached pattern
+
+use std::fmt;
+
+use itertools::Itertools;
+use orchid_base::interner::Tok;
+use orchid_base::name::Sym;
+use orchid_base::side::Side;
+use orchid_base::tokens::{PARENS, Paren};
+
+pub enum ScalMatcher {
+	Name(Sym),
+	S(Paren, Box<AnyMatcher>),
+	Lambda(Box<AnyMatcher>, Box<AnyMatcher>),
+	Placeh { key: Tok<String> },
+}
+
+pub enum VecMatcher {
+	Placeh {
+		key: Tok<String>,
+		nonzero: bool,
+	},
+	Scan {
+		left: Box<VecMatcher>,
+		sep: Vec<ScalMatcher>,
+		right: Box<VecMatcher>,
+		/// The separator traverses the sequence towards this side
+		direction: Side,
+	},
+	Middle {
+		/// Matches the left outer region
+		left: Box<VecMatcher>,
+		/// Matches the left separator
+		left_sep: Vec<ScalMatcher>,
+		/// Matches the middle - can only ever be a plain placeholder
+		mid: Box<VecMatcher>,
+		/// Matches the right separator
+		right_sep: Vec<ScalMatcher>,
+		/// Matches the right outer region
+		right: Box<VecMatcher>,
+		/// Order of significance for sorting equally good projects based on
+		/// the length of matches on either side.
+		///
+		/// Vectorial keys that appear on either side, in priority order
+		key_order: Vec<Tok<String>>,
+	},
+}
+
+pub enum AnyMatcher {
+	Scalar(Vec<ScalMatcher>),
+	Vec { left: Vec<ScalMatcher>, mid: VecMatcher, right: Vec<ScalMatcher> },
+}
+
+// ################ Display ################
+
+impl fmt::Display for ScalMatcher {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		match self {
+			Self::Placeh { key } => write!(f, "${key}"),
+			Self::Name(n) => write!(f, "{n}"),
+			Self::S(t, body) => {
+				let (l, r, _) = PARENS.iter().find(|r| r.2 == *t).unwrap();
+				write!(f, "{l}{body}{r}")
+			},
+			Self::Lambda(arg, body) => write!(f, "\\{arg}.{body}"),
+		}
+	}
+}
+
+impl fmt::Display for VecMatcher {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		match self {
+			Self::Placeh { key, nonzero: true } => write!(f, "...${key}"),
+			Self::Placeh { key, nonzero: false } => write!(f, "..${key}"),
+			Self::Scan { left, sep, right, direction } => {
+				let arrow = if direction == &Side::Left { "<==" } else { "==>" };
+				write!(f, "Scan{{{left} {arrow} {} {arrow} {right}}}", sep.iter().join(" "))
+			},
+			Self::Middle { left, left_sep, mid, right_sep, right, .. } => {
+				let left_sep_s = left_sep.iter().join(" ");
+				let right_sep_s = right_sep.iter().join(" ");
+				write!(f, "Middle{{{left}|{left_sep_s}|{mid}|{right_sep_s}|{right}}}")
+			},
+		}
+	}
+}
+
+impl fmt::Display for AnyMatcher {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		match self {
+			Self::Scalar(s) => {
+				write!(f, "({})", s.iter().join(" "))
+			},
+			Self::Vec { left, mid, right } => {
+				let lefts = left.iter().join(" ");
+				let rights = right.iter().join(" ");
+				write!(f, "[{lefts}|{mid}|{rights}]")
+			},
+		}
+	}
+}

orchid-std/src/macros/rule/state.rs

@@ -0,0 +1,93 @@
+#![allow(unused)]
+use std::any::Any;
+
+use hashbrown::HashMap;
+use orchid_base::interner::Tok;
+use orchid_base::join::join_maps;
+use orchid_base::location::Pos;
+use orchid_base::match_mapping;
+use orchid_base::name::Sym;
+
+use crate::macros::MacTree;
+
+enum StackAction {
+	Return(Box<dyn Any>),
+	Call {
+		target: Box<dyn FnOnce(Box<dyn Any>) -> StackAction>,
+		param: Box<dyn Any>,
+		tail: Box<dyn FnOnce(Box<dyn Any>) -> StackAction>,
+	},
+}
+
+struct Trampoline {
+	stack: Vec<Box<dyn FnOnce(Box<dyn Any>) -> StackAction>>,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum StateEntry<'a> {
+	Vec(&'a [MacTree]),
+	Scalar(&'a MacTree),
+}
+#[derive(Clone, Debug)]
+pub struct MatchState<'a> {
+	placeholders: HashMap<Tok<String>, StateEntry<'a>>,
+	name_posv: HashMap<Sym, Vec<Pos>>,
+}
+impl<'a> MatchState<'a> {
+	pub fn from_ph(key: Tok<String>, entry: StateEntry<'a>) -> Self {
+		Self { placeholders: HashMap::from([(key, entry)]), name_posv: HashMap::new() }
+	}
+	pub fn combine(self, s: Self) -> Self {
+		Self {
+			placeholders: self.placeholders.into_iter().chain(s.placeholders).collect(),
+			name_posv: join_maps::<_, Vec<Pos>>(self.name_posv, s.name_posv, |_, l, r| {
+				l.into_iter().chain(r).collect()
+			}),
+		}
+	}
+	pub fn ph_len(&self, key: &Tok<String>) -> Option<usize> {
+		match self.placeholders.get(key)? {
+			StateEntry::Vec(slc) => Some(slc.len()),
+			_ => None,
+		}
+	}
+	pub fn from_name(name: Sym, location: Pos) -> Self {
+		Self { name_posv: HashMap::from([(name, vec![location])]), placeholders: HashMap::new() }
+	}
+	pub fn remove(&mut self, name: Tok<String>) -> Option<StateEntry<'a>> {
+		self.placeholders.remove(&name)
+	}
+	pub fn mk_owned(self) -> OwnedState {
+		OwnedState {
+			placeholders: (self.placeholders.into_iter())
+				.map(|(k, v)| {
+					(
+						k.clone(),
+						match_mapping!(v, StateEntry => OwnedEntry {
+							Scalar(tree.clone()),
+							Vec(v.to_vec()),
+						}),
+					)
+				})
+				.collect(),
+			name_posv: self.name_posv,
+		}
+	}
+}
+impl Default for MatchState<'static> {
+	fn default() -> Self { Self { name_posv: HashMap::new(), placeholders: HashMap::new() } }
+}
+
+#[derive(Clone, Debug)]
+pub enum OwnedEntry {
+	Vec(Vec<MacTree>),
+	Scalar(MacTree),
+}
+pub struct OwnedState {
+	placeholders: HashMap<Tok<String>, OwnedEntry>,
+	name_posv: HashMap<Sym, Vec<Pos>>,
+}
+impl OwnedState {
+	pub fn get(&self, key: &Tok<String>) -> Option<&OwnedEntry> { self.placeholders.get(key) }
+	pub fn positions(&self, name: &Sym) -> &[Pos] { self.name_posv.get(name).map_or(&[], |v| &v[..]) }
+}

orchid-std/src/macros/rule/vec_attrs.rs

@@ -0,0 +1,16 @@
+use orchid_api::PhKind;
+use orchid_base::interner::Tok;
+use orchid_base::tree::Ph;
+
+use crate::macros::{MacTok, MacTree};
+
+/// Returns the name, priority and at_least_one of the expression if it is
+/// a vectorial placeholder
+#[must_use]
+pub fn vec_attrs(expr: &MacTree) -> Option<(Tok<String>, u8, bool)> {
+	match (*expr.tok).clone() {
+		MacTok::Ph(Ph { kind: PhKind::Vector { priority, at_least_one }, name }) =>
+			Some((name, priority, at_least_one)),
+		_ => None,
+	}
+}

orchid-std/src/macros/rule/vec_match.rs

@@ -0,0 +1,95 @@
+use std::cmp::Ordering;
+
+use itertools::Itertools;
+use orchid_base::name::Sym;
+
+use super::scal_match::scalv_match;
+use super::shared::VecMatcher;
+use super::state::{MatchState, StateEntry};
+use crate::macros::MacTree;
+
+#[must_use]
+pub fn vec_match<'a>(
+	matcher: &VecMatcher,
+	seq: &'a [MacTree],
+	save_loc: &impl Fn(Sym) -> bool,
+) -> Option<MatchState<'a>> {
+	match matcher {
+		VecMatcher::Placeh { key, nonzero } => {
+			if *nonzero && seq.is_empty() {
+				return None;
+			}
+			Some(MatchState::from_ph(key.clone(), StateEntry::Vec(seq)))
+		},
+		VecMatcher::Scan { left, sep, right, direction } => {
+			if seq.len() < sep.len() {
+				return None;
+			}
+			for lpos in direction.walk(0..=seq.len() - sep.len()) {
+				let rpos = lpos + sep.len();
+				let state = vec_match(left, &seq[..lpos], save_loc)
+					.and_then(|s| Some(s.combine(scalv_match(sep, &seq[lpos..rpos], save_loc)?)))
+					.and_then(|s| Some(s.combine(vec_match(right, &seq[rpos..], save_loc)?)));
+				if let Some(s) = state {
+					return Some(s);
+				}
+			}
+			None
+		},
+		// XXX predict heap space usage and allocation count
+		VecMatcher::Middle { left, left_sep, mid, right_sep, right, key_order } => {
+			if seq.len() < left_sep.len() + right_sep.len() {
+				return None;
+			}
+			// Valid locations for the left separator
+			let lposv = seq[..seq.len() - right_sep.len()]
+				.windows(left_sep.len())
+				.enumerate()
+				.filter_map(|(i, window)| scalv_match(left_sep, window, save_loc).map(|s| (i, s)))
+				.collect::<Vec<_>>();
+			// Valid locations for the right separator
+			let rposv = seq[left_sep.len()..]
+				.windows(right_sep.len())
+				.enumerate()
+				.filter_map(|(i, window)| scalv_match(right_sep, window, save_loc).map(|s| (i, s)))
+				.collect::<Vec<_>>();
+			// Valid combinations of locations for the separators
+			let mut pos_pairs = lposv
+				.into_iter()
+				.cartesian_product(rposv)
+				.filter(|((lpos, _), (rpos, _))| lpos + left_sep.len() <= *rpos)
+				.map(|((lpos, lstate), (rpos, rstate))| (lpos, rpos, lstate.combine(rstate)))
+				.collect::<Vec<_>>();
+			// In descending order of size
+			pos_pairs.sort_by_key(|(l, r, _)| -((r - l) as i64));
+			let eql_clusters = pos_pairs.into_iter().chunk_by(|(al, ar, _)| ar - al);
+			for (_gap_size, cluster) in eql_clusters.into_iter() {
+				let best_candidate = cluster
+					.into_iter()
+					.filter_map(|(lpos, rpos, state)| {
+						Some(
+							state
+								.combine(vec_match(left, &seq[..lpos], save_loc)?)
+								.combine(vec_match(mid, &seq[lpos + left_sep.len()..rpos], save_loc)?)
+								.combine(vec_match(right, &seq[rpos + right_sep.len()..], save_loc)?),
+						)
+					})
+					.max_by(|a, b| {
+						for key in key_order {
+							let alen = a.ph_len(key).expect("key_order references scalar or missing");
+							let blen = b.ph_len(key).expect("key_order references scalar or missing");
+							match alen.cmp(&blen) {
+								Ordering::Equal => (),
+								any => return any,
+							}
+						}
+						Ordering::Equal
+					});
+				if let Some(state) = best_candidate {
+					return Some(state);
+				}
+			}
+			None
+		},
+	}
+}