refactor(pc): Introducing MapDecorator (#122)

* refactor(pc): Introducing MapDecorator

Makes parsers that rely on a single underlying parser
and only map the successful result of that parser
slightly less boilerplate in the implementation.

Using a marker trait MapDecoratorMarker to resolve
conflicts in blanket trait implementation of Parser.

* Migrated OrDefaultParser to MapDecorator

* Migrated ToOptionParser to MapDecorator

* Migrated AndThenErrParser to MapDecorator

* Migrated AndThenParser to MapDecorator

* Migrated LazyParser to MapDecorator

* Renamed `specific_trait` to `or_expected`

* Created dedicated ToFatalParser

* Created dedicated MapSoftErrParser

* Created dedicated parser for MapFatalErr

* Implemented `with_expected_message` in pc

* Moved `or_expected` into pc

Author: ngeor

rusty_parser/src/core/dim_name.rs

@@ -172,13 +172,12 @@ mod type_definition {
                     Box::new(built_in_numeric_type()),
                     Box::new(built_in_string()),
                 ];
-                let mut expected_message =
-                    "Expected: INTEGER or LONG or SINGLE or DOUBLE or STRING";
+                let mut expected_message = "INTEGER or LONG or SINGLE or DOUBLE or STRING";
 
                 if allow_user_defined {
                     parsers.push(Box::new(user_defined_type()));
                     expected_message =
-                        "Expected: INTEGER or LONG or SINGLE or DOUBLE or STRING or identifier";
+                        "INTEGER or LONG or SINGLE or DOUBLE or STRING or identifier";
                 }
 
                 OrParser::new(parsers).with_expected_message(expected_message)

rusty_parser/src/core/param_name.rs

@@ -101,9 +101,7 @@ fn extended_type() -> impl Parser<StringView, VarNameCtx, Output = ParamType, Er
         // allow user defined
         built_in_extended_type()
             .or(user_defined_type())
-            .with_expected_message(
-                "Expected: INTEGER or LONG or SINGLE or DOUBLE or STRING or identifier",
-            ),
+            .with_expected_message("INTEGER or LONG or SINGLE or DOUBLE or STRING or identifier"),
         // do not allow user defined
         built_in_extended_type(),
     )

rusty_parser/src/core/sub_call.rs

@@ -4,7 +4,6 @@ use rusty_pc::*;
 use crate::error::ParserError;
 use crate::expr::{csv_expressions_first_guarded, expression_pos_p, property};
 use crate::input::StringView;
-use crate::pc_specific::*;
 use crate::tokens::equal_sign_ws;
 use crate::*;
 

rusty_parser/src/error.rs

@@ -63,7 +63,7 @@ impl ParserError {
     /// Creates a syntax error that starts with "Expected: "
     /// followed by the given string.
     pub fn expected(expectation: &str) -> Self {
-        Self::Expected(format!("Expected: {}", expectation))
+        Self::from(expectation)
     }
 }
 
@@ -98,3 +98,17 @@ impl From<std::num::ParseIntError> for ParserError {
         Self::ParseNumError(e.to_string())
     }
 }
+
+// Needed in order to support with_expected_message
+
+impl From<String> for ParserError {
+    fn from(e: String) -> Self {
+        Self::Expected(format!("Expected: {}", e))
+    }
+}
+
+impl From<&str> for ParserError {
+    fn from(e: &str) -> Self {
+        Self::Expected(format!("Expected: {}", e))
+    }
+}

rusty_parser/src/expr/binary_expression.rs

@@ -5,7 +5,7 @@ use rusty_pc::*;
 use crate::error::ParserError;
 use crate::expr::{expression_pos_p, ws_expr_pos_p};
 use crate::input::StringView;
-use crate::pc_specific::{OrExpected, WithPos, lead_opt_ws, lead_ws};
+use crate::pc_specific::{WithPos, lead_opt_ws, lead_ws};
 use crate::tokens::{TokenType, any_token};
 use crate::{ExpressionPos, ExpressionPosTrait, ExpressionTrait, Keyword, Operator};
 

rusty_parser/src/expr/parenthesis.rs

@@ -2,7 +2,7 @@ use rusty_pc::*;
 
 use crate::expr::expression_pos_p;
 use crate::input::StringView;
-use crate::pc_specific::{OrExpected, WithPos, in_parenthesis};
+use crate::pc_specific::{WithPos, in_parenthesis};
 use crate::{Expression, ExpressionPos, ParserError};
 
 pub(super) fn parser() -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {

rusty_parser/src/expr/parsers.rs

@@ -149,6 +149,6 @@ fn opt_keyword_expr(
     let msg = format!("expression after {}", keyword);
     conditionally_opt_whitespace()
         .and_keep_right(keyword_ignoring(keyword).no_context())
-        .and_keep_right(ws_expr_pos_p().or_expected(&msg).no_context())
+        .and_keep_right(ws_expr_pos_p().or_expected(msg).no_context())
         .to_option()
 }

rusty_parser/src/expr/property.rs

@@ -4,7 +4,6 @@ use rusty_pc::*;
 use crate::core::{name_as_tokens_p, token_to_type_qualifier};
 use crate::error::ParserError;
 use crate::input::StringView;
-use crate::pc_specific::OrExpected;
 use crate::tokens::dot;
 use crate::{BareName, Expression, ExpressionPos, ExpressionType, Name, NameAsTokens};
 

rusty_parser/src/expr/unary_expression.rs

@@ -3,7 +3,7 @@ use rusty_pc::*;
 
 use crate::expr::{expression_pos_p, ws_expr_pos_p};
 use crate::input::StringView;
-use crate::pc_specific::{OrExpected, WithPos, keyword};
+use crate::pc_specific::{WithPos, keyword};
 use crate::tokens::minus_sign;
 use crate::{ExpressionPos, ExpressionPosTrait, Keyword, ParserError, UnaryOperator};
 

rusty_parser/src/pc_specific/csv.rs

@@ -2,7 +2,6 @@ use rusty_pc::*;
 
 use crate::error::ParserError;
 use crate::input::StringView;
-use crate::pc_specific::OrExpected;
 use crate::tokens::comma_ws;
 
 /// Comma separated list of items.