Added demand_ws_expr_ws_keyword_p and ws_expr_ws_keyword_p

Author: ngeor

rusty_parser/src/built_ins/name.rs

@@ -1,16 +1,15 @@
 use rusty_pc::*;
 
-use crate::expr::{ws_expr_pos_p, ws_expr_pos_ws_p};
+use crate::expr::{demand_ws_expr_ws_keyword_p, ws_expr_pos_p};
 use crate::input::StringView;
 use crate::pc_specific::*;
 use crate::{BuiltInSub, ParserError, *};
 
 pub fn parse() -> impl Parser<StringView, Output = Statement, Error = ParserError> {
-    seq4(
+    seq3(
         keyword(Keyword::Name),
-        ws_expr_pos_ws_p().or_expected("old file name"),
-        keyword(Keyword::As),
+        demand_ws_expr_ws_keyword_p("old file name", Keyword::As),
         ws_expr_pos_p().or_expected("new file name"),
-        |_, l, _, r| Statement::built_in_sub_call(BuiltInSub::Name, vec![l, r]),
+        |_, l, r| Statement::built_in_sub_call(BuiltInSub::Name, vec![l, r]),
     )
 }

rusty_parser/src/built_ins/view_print.rs

@@ -1,6 +1,7 @@
+use rusty_pc::and::VecCombiner;
 use rusty_pc::*;
 
-use crate::expr::{ws_expr_pos_p, ws_expr_pos_ws_p};
+use crate::expr::{ws_expr_pos_p, ws_expr_ws_keyword_p};
 use crate::input::StringView;
 use crate::pc_specific::*;
 use crate::{BuiltInSub, ParserError, *};
@@ -12,12 +13,7 @@ pub fn parse() -> impl Parser<StringView, Output = Statement, Error = ParserErro
 }
 
 fn parse_args() -> impl Parser<StringView, Output = Expressions, Error = ParserError> {
-    seq3(
-        ws_expr_pos_ws_p(),
-        keyword(Keyword::To),
-        ws_expr_pos_p().or_expected("expression"),
-        |l, _, r| vec![l, r],
-    )
+    ws_expr_ws_keyword_p(Keyword::To).and(ws_expr_pos_p().or_expected("expression"), VecCombiner)
 }
 
 #[cfg(test)]

rusty_parser/src/core/if_block.rs

@@ -5,7 +5,7 @@ use crate::core::single_line_statements::{
     single_line_non_comment_statements_p, single_line_statements_p
 };
 use crate::core::statements::zero_or_more_statements;
-use crate::expr::ws_expr_pos_ws_p;
+use crate::expr::demand_ws_expr_ws_keyword_p;
 use crate::input::StringView;
 use crate::pc_specific::*;
 use crate::{ParserError, *};
@@ -35,12 +35,10 @@ pub fn if_block_p() -> impl Parser<StringView, Output = Statement, Error = Parse
 // multi line if    ::= statements else-if-blocks else-block END IF
 
 fn if_expr_then_p() -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {
-    seq3(
-        keyword(Keyword::If),
-        ws_expr_pos_ws_p().or_expected("expression after IF"),
-        keyword(Keyword::Then),
-        |_, m, _| m,
-    )
+    keyword(Keyword::If).and_keep_right(demand_ws_expr_ws_keyword_p(
+        "expression after IF",
+        Keyword::Then,
+    ))
 }
 
 fn single_line_if_else_p() -> impl Parser<
@@ -79,12 +77,10 @@ fn multi_line_if_p() -> impl Parser<
 }
 
 fn else_if_expr_then_p() -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {
-    seq3(
-        keyword(Keyword::ElseIf),
-        ws_expr_pos_ws_p().or_expected("expression after ELSEIF"),
-        keyword(Keyword::Then),
-        |_, m, _| m,
-    )
+    keyword(Keyword::ElseIf).and_keep_right(demand_ws_expr_ws_keyword_p(
+        "expression after ELSEIF",
+        Keyword::Then,
+    ))
 }
 
 fn else_if_block_p() -> impl Parser<StringView, Output = ConditionalBlock, Error = ParserError> {

rusty_parser/src/expr/parsers.rs

@@ -105,6 +105,22 @@ pub fn demand_expr_ws_keyword_p(
     )
 }
 
+pub fn ws_expr_ws_keyword_p(
+    keyword: Keyword,
+) -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {
+    expr_ws_followed_by(ws_expr_pos_p(), keyword_ignoring(keyword))
+}
+
+pub fn demand_ws_expr_ws_keyword_p(
+    expectation: &str,
+    keyword: Keyword,
+) -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {
+    expr_ws_followed_by(
+        ws_expr_pos_p().or_expected(expectation),
+        keyword_ignoring(keyword),
+    )
+}
+
 /// Parses the expression using the given parser,
 /// then demands whitespace, unless the expression is a parenthesis.
 /// Finally it demands the second parser.

rusty_pc/src/and.rs

@@ -103,9 +103,17 @@ where
     }
 }
 
-/// Combines two vectors by concatenating them into one.
+/// Combines items into a vector.
 pub struct VecCombiner;
 
+/// Combines two items into a vector.
+impl<L> Combiner<L, L, Vec<L>> for VecCombiner {
+    fn combine(&self, left: L, right: L) -> Vec<L> {
+        vec![left, right]
+    }
+}
+
+/// Combines two vectors by concatenating them into one.
 impl<L> Combiner<Vec<L>, Vec<L>, Vec<L>> for VecCombiner {
     fn combine(&self, mut left: Vec<L>, mut right: Vec<L>) -> Vec<L> {
         left.append(&mut right);