Updated everything and moved to hard tab indentation

orchid-host/src/rule/state.rs

@@ -11,83 +11,81 @@ 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>
-  }
+	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>>
+	stack: Vec<Box<dyn FnOnce(Box<dyn Any>) -> StackAction>>,
 }
 
-
-
 #[derive(Clone, Copy, Debug)]
 pub enum StateEntry<'a> {
-  Vec(&'a [MacTree]),
-  Scalar(&'a MacTree),
+	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>>,
+	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(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,
-    }
-  }
+	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(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() } }
+	fn default() -> Self { Self { name_posv: HashMap::new(), placeholders: HashMap::new() } }
 }
 
 #[derive(Clone, Debug)]
 pub enum OwnedEntry {
-  Vec(Vec<MacTree>),
-  Scalar(MacTree),
+	Vec(Vec<MacTree>),
+	Scalar(MacTree),
 }
 pub struct OwnedState {
-  placeholders: HashMap<Tok<String>, OwnedEntry>,
-  name_posv: HashMap<Sym, Vec<Pos>>,
+	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[..]) }
+	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[..]) }
 }