From a6edd2e9cc52a73d188eb9144912f4a47eb90e19 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Patrick=20L=C3=BChne?= <patrick@luehne.de>
Date: Tue, 28 Apr 2020 02:14:27 +0200
Subject: [PATCH] Clean-up

---
 src/parse/tokens.rs | 154 +-------------------------------------------
 1 file changed, 1 insertion(+), 153 deletions(-)

diff --git a/src/parse/tokens.rs b/src/parse/tokens.rs
index 2dc4a3a..3894e30 100644
--- a/src/parse/tokens.rs
+++ b/src/parse/tokens.rs
@@ -327,7 +327,7 @@ impl<'i> Tokens<'i, ()>
 	pub fn new_filter<P>(input: &'i str, mut predicate: P)
 		-> Tokens<'i, impl FnMut(Token<'i>) -> Option<Token<'i>>>
 	where
-		P: FnMut(&Token<'i>) -> bool
+		P: FnMut(&Token<'i>) -> bool,
 	{
 		Tokens::new_filter_map(input,
 			move |x|
@@ -517,158 +517,6 @@ where
 	}
 }
 
-/*pub(crate) struct TokenIterator<'i>
-{
-	original_input: &'i str,
-	input: &'i str,
-}
-
-impl<'i> TokenIterator<'i>
-{
-	pub fn new(input: &'i str) -> Self
-	{
-		Self
-		{
-			original_input: input,
-			input,
-		}
-	}
-}
-
-impl<'i> std::iter::Iterator for TokenIterator<'i>
-{
-	type Item = Result<(usize, usize, Token<'i>), crate::parse::Error>;
-
-	fn next(&mut self) -> Option<Self::Item>
-	{
-		self.input = self.input.trim_start();
-		let index_left = substring_offset(self.input, self.original_input);
-
-		let first_character = match self.input.chars().next()
-		{
-			None => return None,
-			Some(first_character) => first_character,
-		};
-
-		if self.input.starts_with(")")
-		{
-			return Some(Err(crate::parse::Error::new_unmatched_parenthesis(
-				crate::parse::error::Location::new(0, Some(1)))));
-		}
-
-		match parenthesized_expression(self.input)
-		{
-			Ok(Some((parenthesized_expression, remaining_input))) =>
-			{
-				self.input = remaining_input;
-				let index_right = substring_offset(self.input, self.original_input);
-
-				return Some(Ok((index_left, index_right,
-					Token::ParenthesizedExpression(parenthesized_expression))));
-			},
-			Ok(None) => (),
-			Err(error) => return Some(Err(error)),
-		}
-
-		match number(self.input)
-		{
-			Ok(Some((number, remaining_input))) =>
-			{
-				self.input = remaining_input;
-				let index_right = substring_offset(self.input, self.original_input);
-
-				return Some(Ok((index_left, index_right, Token::Number(number))));
-			},
-			Ok(None) => (),
-			Err(error) => return Some(Err(error)),
-		}
-
-		if let Some((identifier, remaining_input)) = identifier(self.input)
-		{
-			self.input = remaining_input;
-			let index_right = substring_offset(self.input, self.original_input);
-
-			return Some(Ok((index_left, index_right, Token::Identifier(identifier))));
-		}
-
-		if let Some((symbol, remaining_input)) = symbol(self.input)
-		{
-			self.input = remaining_input;
-			let index_right = substring_offset(self.input, self.original_input);
-
-			return Some(Ok((index_left, index_right, Token::Symbol(symbol))));
-		}
-
-		return Some(Err(crate::parse::Error::new_character_not_allowed(first_character,
-			crate::parse::error::Location::new(0, Some(0)))));
-	}
-}
-
-pub(crate) struct TokenSplit<'i, T, U>
-where
-	T: std::iter::Iterator<Item = Result<(usize, usize, U), crate::parse::Error>>
-{
-	token_iterator: T,
-	original_input: &'i str,
-	previous_index: usize,
-}
-
-impl<'i, T, U> TokenSplit<'i, T, U>
-where
-	T: std::iter::Iterator<Item = Result<(usize, usize, U), crate::parse::Error>>
-{
-	pub fn new(token_iterator: T, original_input: &'i str) -> Self
-	{
-		Self
-		{
-			token_iterator,
-			original_input,
-			previous_index: 0,
-		}
-	}
-}
-
-impl<'i, T, U> std::iter::Iterator for TokenSplit<'i, T, U>
-where
-	T: std::iter::Iterator<Item = Result<(usize, usize, U), crate::parse::Error>>
-{
-	type Item = Result<&'i str, crate::parse::Error>;
-
-	fn next(&mut self) -> Option<Self::Item>
-	{
-		if self.previous_index == self.original_input.len()
-		{
-			return None;
-		}
-
-		loop
-		{
-			match self.token_iterator.next()
-			{
-				Some(Ok((index_left, index_right, token))) =>
-				{
-					let input_between = self.original_input[self.previous_index..index_left].trim();
-
-					assert!(!input_between.is_empty());
-
-					self.previous_index = index_right;
-
-					return Some(Ok(input_between));
-				},
-				Some(Err(error)) => return Some(Err(error)),
-				None =>
-				{
-					let remaining_input = self.original_input[self.previous_index..].trim();
-
-					self.previous_index = self.original_input.len();
-
-					return Some(Ok(remaining_input));
-				},
-			}
-		}
-	}
-}*/
-
 #[cfg(test)]
 mod tests
 {