idle cleanup (#147)

src/error.rs

@@ -8,14 +8,15 @@ use nom::{
 };
 
 #[derive(PartialEq, Eq, Debug, Clone)]
+#[non_exhaustive]
 pub enum Error {
     ParseError(String),
     GenerateError(String),
 }
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
+        match self {
             Error::ParseError(ref s) | Error::GenerateError(ref s) => write!(f, "{s}"),
         }
     }

src/expression.rs

@@ -60,14 +60,12 @@ impl Expression {
 
     /// Get iterator of `Term`s within `Expression`
     pub fn terms_iter(&self) -> impl Iterator<Item = &Term> {
-        crate::slice_iter::SliceIter { slice: &self.terms }
+        self.terms.iter()
     }
 
     /// Get mutable iterator of `Term`s within `Expression`
     pub fn terms_iter_mut(&mut self) -> impl Iterator<Item = &mut Term> {
-        crate::slice_iter::SliceIterMut {
-            slice: &mut self.terms,
-        }
+        self.terms.iter_mut()
     }
 
     /// Determine if this expression terminates or not, i.e contains all terminal elements or every

src/grammar.rs

@@ -133,14 +133,12 @@ impl<'gram> ParseTree<'gram> {
 
     /// Iterate the "right hand side" parse tree nodes
     pub fn rhs_iter(&self) -> impl Iterator<Item = &ParseTreeNode> {
-        crate::slice_iter::SliceIter { slice: &self.rhs }
+        self.rhs.iter()
     }
 
     /// Mutably iterate the "right hand side" parse tree nodes
     pub fn rhs_iter_mut<'a>(&'a mut self) -> impl Iterator<Item = &'a mut ParseTreeNode<'gram>> {
-        crate::slice_iter::SliceIterMut {
-            slice: &mut self.rhs,
-        }
+        self.rhs.iter_mut()
     }
 }
 
@@ -240,16 +238,12 @@ impl Grammar {
 
     /// Get iterator of the `Grammar`'s `Production`s
     pub fn productions_iter(&self) -> impl Iterator<Item = &Production> {
-        crate::slice_iter::SliceIter {
-            slice: &self.productions,
-        }
+        self.productions.iter()
     }
 
     /// Get mutable iterator of the `Grammar`'s `Production`s
     pub fn productions_iter_mut(&mut self) -> impl Iterator<Item = &mut Production> {
-        crate::slice_iter::SliceIterMut {
-            slice: &mut self.productions,
-        }
+        self.productions.iter_mut()
     }
 
     /// Parse input strings according to `Grammar`
@@ -470,9 +464,7 @@ impl Grammar {
             }
         }
 
-        terminating_rules
-            .into_iter()
-            .any(|term| term == starting_term)
+        terminating_rules.contains(&starting_term)
     }
 }
 

src/lib.rs

@@ -7,7 +7,6 @@ mod expression;
 mod grammar;
 mod parsers;
 mod production;
-mod slice_iter;
 mod term;
 mod tracing;
 pub use crate::error::Error;

src/production.rs

@@ -51,14 +51,12 @@ impl Production {
 
     /// Get iterator of the `Production`'s right hand side `Expression`s
     pub fn rhs_iter(&self) -> impl Iterator<Item = &Expression> {
-        crate::slice_iter::SliceIter { slice: &self.rhs }
+        self.rhs.iter()
     }
 
     /// Get mutable iterator of the `Production`'s right hand side `Expression`s
     pub fn rhs_iter_mut(&mut self) -> impl Iterator<Item = &mut Expression> {
-        crate::slice_iter::SliceIterMut {
-            slice: &mut self.rhs,
-        }
+        self.rhs.iter_mut()
     }
 
     /// Get number of right hand side `Expression`s