Created dedicated MapSoftErrParser

Author: ngeor

rusty_parser/src/pc_specific/or_expected.rs

@@ -1,4 +1,4 @@
-use rusty_pc::map_err::{MapErrParser, SoftErrorOverrider};
+use rusty_pc::map_soft_err::MapSoftErrParser;
 use rusty_pc::{Parser, ParserErrorTrait};
 
 use crate::error::ParserError;
@@ -11,7 +11,7 @@ where
     /// Demands a successful result or returns a fatal syntax error
     /// with an error message like "Expected: " followed by the
     /// given expectation message.
-    fn or_expected(self, expectation: &str) -> MapErrParser<Self, SoftErrorOverrider<Self::Error>> {
+    fn or_expected(self, expectation: &str) -> MapSoftErrParser<Self, Self::Error> {
         self.or_fail(ParserError::expected(expectation).to_fatal())
     }
 }

rusty_pc/src/lib.rs

@@ -17,6 +17,7 @@ pub mod map;
 pub mod map_ctx;
 pub mod map_decorator;
 pub mod map_err;
+pub mod map_soft_err;
 pub mod no_context;
 mod or;
 pub mod or_default;

rusty_pc/src/map_err.rs

@@ -42,24 +42,6 @@ where
     fn map(&self, err: E) -> E;
 }
 
-/// Overrides a soft error with the given value.
-pub struct SoftErrorOverrider<E>(E);
-
-impl<E> SoftErrorOverrider<E> {
-    pub fn new(err: E) -> Self {
-        Self(err)
-    }
-}
-
-impl<E> ErrorMapper<E> for SoftErrorOverrider<E>
-where
-    E: ParserErrorTrait,
-{
-    fn map(&self, err: E) -> E {
-        if err.is_soft() { self.0.clone() } else { err }
-    }
-}
-
 /// Overrides a fatal error with the given value.
 pub struct FatalErrorOverrider<E>(E);
 

rusty_pc/src/map_soft_err.rs

@@ -0,0 +1,40 @@
+use crate::map_decorator::{MapDecorator, MapDecoratorMarker};
+use crate::{InputTrait, Parser, ParserErrorTrait};
+
+pub struct MapSoftErrParser<P, E> {
+    parser: P,
+    err: E,
+}
+
+impl<P, E> MapSoftErrParser<P, E> {
+    pub(crate) fn new(parser: P, err: E) -> Self {
+        Self { parser, err }
+    }
+}
+
+impl<I, C, P, E> MapDecorator<I, C> for MapSoftErrParser<P, E>
+where
+    I: InputTrait,
+    P: Parser<I, C, Error = E>,
+    E: ParserErrorTrait,
+{
+    type OriginalOutput = P::Output;
+    type Output = P::Output;
+    type Error = E;
+
+    fn decorated(
+        &mut self,
+    ) -> &mut impl Parser<I, C, Output = Self::OriginalOutput, Error = Self::Error> {
+        &mut self.parser
+    }
+
+    fn map_ok(&self, ok: Self::OriginalOutput) -> Result<Self::Output, Self::Error> {
+        Ok(ok)
+    }
+
+    fn map_soft_error(&self, _err: Self::Error) -> Result<Self::Output, Self::Error> {
+        Err(self.err.clone())
+    }
+}
+
+impl<P, E> MapDecoratorMarker for MapSoftErrParser<P, E> {}

rusty_pc/src/parser.rs

@@ -10,7 +10,8 @@ use crate::flatten::FlattenParser;
 use crate::many::{ManyCombiner, ManyParser, VecManyCombiner};
 use crate::map::{MapParser, MapToUnitParser};
 use crate::map_ctx::MapCtxParser;
-use crate::map_err::{ErrorMapper, FatalErrorOverrider, MapErrParser, SoftErrorOverrider};
+use crate::map_err::{ErrorMapper, FatalErrorOverrider, MapErrParser};
+use crate::map_soft_err::MapSoftErrParser;
 use crate::no_context::NoContextParser;
 use crate::or_default::OrDefaultParser;
 use crate::peek::PeekParser;
@@ -289,7 +290,7 @@ where
     }
 
     // =======================================================================
-    // MapErr
+    // MapSoftErr
     // =======================================================================
 
     /// Maps the error of this parser.
@@ -306,16 +307,16 @@ where
 
     /// If this parser returns a soft error, the soft error will be replaced by
     /// the given error (which might be soft or fatal).
-    fn with_soft_err(self, err: Self::Error) -> MapErrParser<Self, SoftErrorOverrider<Self::Error>>
+    fn with_soft_err(self, err: Self::Error) -> MapSoftErrParser<Self, Self::Error>
     where
         Self: Sized,
     {
-        self.map_err(SoftErrorOverrider::new(err))
+        MapSoftErrParser::new(self, err)
     }
 
     /// If this parser returns a soft error, the soft error will be replaced by
     /// the given error, which must be fatal.
-    fn or_fail(self, err: Self::Error) -> MapErrParser<Self, SoftErrorOverrider<Self::Error>>
+    fn or_fail(self, err: Self::Error) -> MapSoftErrParser<Self, Self::Error>
     where
         Self: Sized,
     {