Created dedicated parser for MapFatalErr

Author: ngeor

rusty_pc/src/lib.rs

@@ -16,7 +16,7 @@ pub mod many_ctx;
 pub mod map;
 pub mod map_ctx;
 pub mod map_decorator;
-pub mod map_err;
+pub mod map_fatal_err;
 pub mod map_soft_err;
 pub mod no_context;
 mod or;

rusty_pc/src/map_err.rs

@@ -0,0 +1,35 @@
+use crate::{InputTrait, Parser, ParserErrorTrait};
+
+/// A parser that maps the error of the decorated parser
+/// using the given mapper.
+pub struct MapFatalErrParser<P, E> {
+    parser: P,
+    err: E,
+}
+
+impl<P, E> MapFatalErrParser<P, E> {
+    pub(crate) fn new(parser: P, err: E) -> Self {
+        Self { parser, err }
+    }
+}
+
+impl<I, C, P, E> Parser<I, C> for MapFatalErrParser<P, E>
+where
+    I: InputTrait,
+    P: Parser<I, C, Error = E>,
+    E: ParserErrorTrait,
+{
+    type Output = P::Output;
+    type Error = P::Error;
+
+    fn parse(&mut self, input: &mut I) -> Result<Self::Output, Self::Error> {
+        match self.parser.parse(input) {
+            Ok(value) => Ok(value),
+            Err(_) => Err(self.err.clone()),
+        }
+    }
+
+    fn set_context(&mut self, ctx: &C) {
+        self.parser.set_context(ctx)
+    }
+}

rusty_pc/src/map_fatal_err.rs

@@ -10,7 +10,7 @@ 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};
+use crate::map_fatal_err::MapFatalErrParser;
 use crate::map_soft_err::MapSoftErrParser;
 use crate::no_context::NoContextParser;
 use crate::or_default::OrDefaultParser;
@@ -290,21 +290,25 @@ where
     }
 
     // =======================================================================
-    // MapSoftErr
+    // MapFatalErr
     // =======================================================================
 
-    /// Maps the error of this parser.
+    /// Maps the fatal error of this parser.
     /// If the parser is successful, the value is returned as-is.
-    /// If the parser returns an error, the given mapper is used to map the error
-    /// to a new error.
-    fn map_err<F>(self, mapper: F) -> MapErrParser<Self, F>
+    /// If the parser returns a soft error, the error is returned as-is.
+    /// If the parser returns a fatal error, it is replaced by the given error.
+    fn map_fatal_err(self, err: Self::Error) -> MapFatalErrParser<Self, Self::Error>
     where
         Self: Sized,
-        F: ErrorMapper<Self::Error>,
     {
-        MapErrParser::new(self, mapper)
+        assert!(err.is_fatal());
+        MapFatalErrParser::new(self, err)
     }
 
+    // =======================================================================
+    // MapSoftErr
+    // =======================================================================
+
     /// 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) -> MapSoftErrParser<Self, Self::Error>
@@ -324,19 +328,6 @@ where
         self.with_soft_err(err)
     }
 
-    /// If this parser returns a fatal error, the fatal error will be replaced by the given error
-    /// (which must be fatal too).
-    fn with_fatal_err(
-        self,
-        err: Self::Error,
-    ) -> MapErrParser<Self, FatalErrorOverrider<Self::Error>>
-    where
-        Self: Sized,
-    {
-        assert!(err.is_fatal());
-        self.map_err(FatalErrorOverrider::new(err))
-    }
-
     // =======================================================================
     // NoContext
     // =======================================================================