chore(pc): Removed and_opt parser, adding one_of_p

Author: ngeor

rusty_parser/src/core/dim_name.rs

@@ -212,12 +212,15 @@ mod type_definition {
     }
 
     fn built_in_string() -> impl Parser<StringView, Output = DimType, Error = ParserError> {
-        keyword(Keyword::String).and_opt(
-            star_ws().and_keep_right(expression_pos_p().or_expected("string length after *")),
-            |_, opt_len| match opt_len {
+        keyword(Keyword::String)
+            .and_keep_right(star_and_length().to_option())
+            .map(|opt_len| match opt_len {
                 Some(len) => DimType::FixedLengthString(len, 0),
                 _ => DimType::BuiltIn(TypeQualifier::DollarString, BuiltInStyle::Extended),
-            },
-        )
+            })
+    }
+
+    fn star_and_length() -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {
+        star_ws().and_keep_right(expression_pos_p().or_expected("string length after *"))
     }
 }

rusty_parser/src/core/global_statement.rs

@@ -151,11 +151,9 @@ pub fn program_parser_p() -> impl Parser<StringView, Output = Program, Error = P
 }
 
 fn main_program() -> impl Parser<StringView, Output = Program, Error = ParserError> {
-    global_statement_pos_p().and_opt(next_statements(), |first, opt_next| {
+    global_statement_pos_p().and(next_statements(), |first, mut opt_next| {
         let mut program = vec![first];
-        if let Some(next) = opt_next {
-            program.extend(next);
-        }
+        program.append(&mut opt_next);
         program
     })
 }

rusty_parser/src/core/if_block.rs

@@ -50,15 +50,19 @@ fn single_line_if_else_p() -> impl Parser<
     Output = (Statements, Vec<ConditionalBlock>, Option<Statements>),
     Error = ParserError,
 > {
-    single_line_non_comment_statements_p().and_opt(
+    single_line_non_comment_statements_p().and(
         // comment or ELSE
-        whitespace_ignoring()
-            .and(comment_p().with_pos(), |_, s| vec![s])
-            .or(single_line_else_p()),
+        single_line_comment_p().or(single_line_else_p()).to_option(),
         |l, r| (l, vec![], r),
     )
 }
 
+fn single_line_comment_p() -> impl Parser<StringView, Output = Statements, Error = ParserError> {
+    whitespace_ignoring()
+        .to_option()
+        .and(comment_p().with_pos(), |_, s| vec![s])
+}
+
 fn single_line_else_p() -> impl Parser<StringView, Output = Statements, Error = ParserError> {
     whitespace_ignoring()
         .and(keyword(Keyword::Else), IgnoringBothCombiner)

rusty_parser/src/core/implementation.rs

@@ -1,4 +1,4 @@
-use rusty_pc::and::{IgnoringBothCombiner, opt_and};
+use rusty_pc::and::IgnoringBothCombiner;
 use rusty_pc::*;
 
 use crate::core::declaration::{function_declaration_p, sub_declaration_p};
@@ -56,14 +56,13 @@ fn static_declaration_p<P, T>(
 where
     P: Parser<StringView, Output = T, Error = ParserError>,
 {
-    parser.and_opt(
-        opt_and(
-            whitespace_ignoring(),
-            keyword(Keyword::Static),
-            IgnoringBothCombiner,
-        ),
-        |l, r: Option<()>| (l, r.is_some()),
-    )
+    parser.and(ws_static().to_option(), |l, r: Option<()>| (l, r.is_some()))
+}
+
+fn ws_static() -> impl Parser<StringView, Output = (), Error = ParserError> {
+    whitespace_ignoring()
+        .to_option()
+        .and(keyword(Keyword::Static), IgnoringBothCombiner)
 }
 
 #[cfg(test)]

rusty_parser/src/tokens/any_token.rs

@@ -53,7 +53,7 @@ fn eol() -> impl Parser<StringView, Output = Token, Error = ParserError> {
 
 fn cr_or_crlf() -> impl Parser<StringView, Output = Token, Error = ParserError> {
     one_p('\r')
-        .and_opt(one_p('\n'), StringCombiner)
+        .and(one_p('\n').to_option(), StringCombiner)
         .to_token(TokenType::Eol)
 }
 
@@ -62,18 +62,20 @@ fn lf() -> impl Parser<StringView, Output = Token, Error = ParserError> {
 }
 
 fn gt_or_ge() -> impl Parser<StringView, Output = Token, Error = ParserError> {
-    one_p('>').and_opt(one_p('='), StringCombiner).map(|text| {
-        if text.len() == 1 {
-            Token::new(TokenType::Greater.get_index(), text)
-        } else {
-            Token::new(TokenType::GreaterEquals.get_index(), text)
-        }
-    })
+    one_p('>')
+        .and(one_p('=').to_option(), StringCombiner)
+        .map(|text| {
+            if text.len() == 1 {
+                Token::new(TokenType::Greater.get_index(), text)
+            } else {
+                Token::new(TokenType::GreaterEquals.get_index(), text)
+            }
+        })
 }
 
 fn lt_or_le_or_ne() -> impl Parser<StringView, Output = Token, Error = ParserError> {
     one_p('<')
-        .and_opt(one_p('>').or(one_p('=')), StringCombiner)
+        .and(one_of_p(&['>', '=']).to_option(), StringCombiner)
         .map(|text| {
             if text.len() == 1 {
                 Token::new(TokenType::Less.get_index(), text)

rusty_pc/src/parser.rs

@@ -66,18 +66,6 @@ where
         self.and(right, KeepRightCombiner)
     }
 
-    /// Parses the left side and optionally the right side.
-    /// The combiner function maps the left and (optional) right output to the final result.
-    /// TODO #[deprecated]
-    fn and_opt<R, F, O>(self, right: R, combiner: F) -> AndParser<Self, ToOptionParser<R>, F, O>
-    where
-        Self: Sized,
-        R: Parser<I, C, Error = Self::Error>,
-        F: Combiner<Self::Output, Option<R::Output>, O>,
-    {
-        self.and(right.to_option(), combiner)
-    }
-
     // =======================================================================
     // AndThen
     // =======================================================================

rusty_pc/src/top_level.rs

@@ -74,3 +74,14 @@ where
 {
     read_p().filter(move |x: &O| *x == needle)
 }
+
+/// Parses one of the given elements.
+/// Note that the operation has O(n) complexity.
+pub fn one_of_p<I, O, E>(needles: &[O]) -> impl Parser<I, Output = O, Error = E>
+where
+    I: InputTrait<Output = O>,
+    O: PartialEq,
+    E: ParserErrorTrait,
+{
+    read_p().filter(move |x: &O| needles.contains(x))
+}