make OrExactMatch take Vec<String> over Vec<&'static str>

examples/alphanum.rs

···
+use mipl::prelude::*;
+
+pub fn alphanum_vec() -> Vec<char> {
+    let mut vec: Vec<char> = vec![];
+
+    for i in 65..91 {
+        vec.push(char::from_u32(i).unwrap());
+    }
+    for i in 97..123 {
+        vec.push(char::from_u32(i).unwrap());
+    }
+    for i in 48..58 {
+        vec.push(char::from_u32(i).unwrap());
+    }
+
+    vec
+}
+
+pub fn tokenize(src: String) -> Parser {
+    let alphanum_vec: Vec<char> = alphanum_vec();
+
+    let del_param = DelimitersParam{
+        discard: DiscardDelimiters::new(
+            vec![
+                ' ',
+                '\n',
+                '\t'
+            ]
+        ),
+        keep: KeepDelimiters::new(
+            alphanum_vec
+        )
+    };
+
+    Parser::from(src, del_param)
+}
+
+fn parse(parser: &mut Parser) -> bool {
+    let alph_vec: Vec<String> = alphanum_vec()
+        .into_iter()
+        .map(|ch| char::to_string(&ch))
+        .collect();
+    let _collector = CollectWhile::<OrExactMatch>::subparse(alph_vec, parser);
+
+    if let Some(tok) = parser.next() {
+        match tok {
+            Token::End(EndToken) => true,
+            _ => false
+        }
+    } else {
+        true
+    }
+}
+
+fn main() {
+    use std::io::Write;
+    loop {
+        print!("check if alphanumeric: ");
+        std::io::stdout().flush().unwrap();
+        let input = {
+            let mut buf = String::new();
+            std::io::stdin().read_line(&mut buf).unwrap();
+            buf
+        };
+        if input.trim() == "exit" {
+            break;
+        }
+        let mut parser = tokenize(input);
+        println!("{}", parse(&mut parser))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_true_alphanum1() {
+        let input = String::from("helix123");
+        let mut parser = tokenize(input);
+        assert_eq!(
+            parse(&mut parser),
+            true
+        )
+    }
+
+    #[test]
+    fn test_false_alphanum1() {
+        let input = String::from("13wonder*");
+        let mut parser = tokenize(input);
+        assert_eq!(
+            parse(&mut parser),
+            false
+        )
+    }
+}

examples/calc.rs

···
 fn consume_term(parser: &mut Parser) -> Option<f32> {
     let mut num: f32 = consume_fact(parser)?;
 
-    let ops = vec!["*", "/"];
+    let ops: Vec<String> = vec!["*", "/"]
+        .into_iter()
+        .map(String::from)
+        .collect();
     let or_matcher = OrExactMatch::new(ops);
     while let Some(op) = or_matcher.try_next(parser) {
         match op.as_ref() {
···
 fn consume_expr(parser: &mut Parser) -> Option<f32> {
     let mut term: f32 = consume_term(parser)?;
 
-    let ops = vec!["+", "-"];
+    let ops: Vec<String> = vec!["+", "-"]
+        .into_iter()
+        .map(String::from)
+        .collect();
     let or_matcher = OrExactMatch::new(ops);
     while let Some(op) = or_matcher.try_next(parser) {
         match op.as_ref() {

src/parser/concrete_parser/or_exact_match.rs

···
     }
 }
 
-impl IsContainerCpInput for Vec<&'static str> {}
+impl IsContainerCpInput for Vec<String> {}
 impl ContainedType for HashSet<String> {}
 
 impl ContainerCp for OrExactMatch {
     type ContainedType = HashSet<String>;
-    type Input = Vec<&'static str>;
+    type Input = Vec<String>;
 
     fn new_contained(value: Self::Input) -> Self::ContainedType {
-        let final_val = value.iter().cloned().map(String::from);
-
-        HashSet::from_iter(final_val)
+        HashSet::from_iter(value)
     }
 
     fn new(value: Self::Input) -> Self {

tests/test_subparser.rs

···
     Parser::from(src, del_param)
 }
 
-#[derive(Debug)]
-pub struct Parsers {
-    /// The parser for expressions
-    expr_parser: Parser,
-    /// The parser for initial configuration
-    states_parser: Parser,
-    /// The number of steps to take
-    steps: usize
-}
-impl Parsers {
-    pub fn new(parser: &mut Parser) -> Option<Self> {
-        let states = vec!["*", "#"];
-        let expr_parser = CollectUntil::<OrExactMatch>::subparse(states.clone(), parser);
-        let states_parser = CollectWhile::<OrExactMatch>::subparse(states, parser);
-        let steps: usize = match parser.next() {
-            Some(Token::Str(s)) => s.parse().ok(),
-            _ => None
-        }?;
+fn test_until_doesnt_eat_ending_states_subparser(parser: &mut Parser) -> Parser {
+    let states: Vec<String> = vec!["*", "#"]
+        .into_iter()
+        .map(String::from)
+        .collect();
+    let _expr_parser = CollectUntil::<OrExactMatch>::subparse(states.clone(), parser);
+    let states_parser = CollectWhile::<OrExactMatch>::subparse(states, parser);
 
-        Some(Parsers {
-            expr_parser,
-            states_parser,
-            steps
-        })
-    }
+    states_parser
 }
 
 #[test]
···
 
     let known_parser_a = tokenize("**#".to_string());
 
-    let parsers = Parsers::new(&mut flat_parser).unwrap();
+    let states_parser = test_until_doesnt_eat_ending_states_subparser(&mut flat_parser);
 
-    assert_parsers_same_till(known_parser_a, parsers.states_parser, 3);
+    assert_parsers_same_till(known_parser_a, states_parser, 3);
 }