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.

Author: ngeor

rusty_pc/src/lib.rs

@@ -15,6 +15,7 @@ pub mod many;
 pub mod many_ctx;
 pub mod map;
 pub mod map_ctx;
+pub mod map_decorator;
 pub mod map_err;
 pub mod no_context;
 mod or;

rusty_pc/src/map.rs

@@ -1,3 +1,4 @@
+use crate::map_decorator::{MapDecorator, MapDecoratorMarker};
 use crate::{InputTrait, Parser};
 
 pub struct MapParser<P, F> {
@@ -11,23 +12,27 @@ impl<P, F> MapParser<P, F> {
     }
 }
 
-impl<I, C, P, F, U> Parser<I, C> for MapParser<P, F>
+impl<I, C, P, F, U> MapDecorator<I, C> for MapParser<P, F>
 where
     I: InputTrait,
     P: Parser<I, C>,
     F: Fn(P::Output) -> U,
 {
+    type OriginalOutput = P::Output;
     type Output = U;
     type Error = P::Error;
-    fn parse(&mut self, tokenizer: &mut I) -> Result<Self::Output, Self::Error> {
-        self.parser.parse(tokenizer).map(&self.mapper)
+
+    fn decorated(&mut self) -> &mut impl Parser<I, C, Output = P::Output, Error = P::Error> {
+        &mut self.parser
     }
 
-    fn set_context(&mut self, ctx: &C) {
-        self.parser.set_context(ctx)
+    fn map_ok(&self, ok: P::Output) -> U {
+        (self.mapper)(ok)
     }
 }
 
+impl<P, F> MapDecoratorMarker for MapParser<P, F> {}
+
 /// MapToUnitParser is the same as `.map(|_| ())`.
 pub struct MapToUnitParser<P> {
     parser: P,
@@ -39,22 +44,20 @@ impl<P> MapToUnitParser<P> {
     }
 }
 
-impl<I, C, P> Parser<I, C> for MapToUnitParser<P>
+impl<I, C, P> MapDecorator<I, C> for MapToUnitParser<P>
 where
     I: InputTrait,
     P: Parser<I, C>,
 {
+    type OriginalOutput = P::Output;
     type Output = ();
     type Error = P::Error;
 
-    fn parse(&mut self, input: &mut I) -> Result<Self::Output, Self::Error> {
-        match self.parser.parse(input) {
-            Ok(_) => Ok(()),
-            Err(err) => Err(err),
-        }
+    fn decorated(&mut self) -> &mut impl Parser<I, C, Output = P::Output, Error = P::Error> {
+        &mut self.parser
     }
 
-    fn set_context(&mut self, ctx: &C) {
-        self.parser.set_context(ctx)
-    }
+    fn map_ok(&self, _ok: P::Output) {}
 }
+
+impl<P> MapDecoratorMarker for MapToUnitParser<P> {}

rusty_pc/src/map_decorator.rs

@@ -0,0 +1,43 @@
+use crate::{InputTrait, Parser, ParserErrorTrait};
+
+/// A parser decorator that maps the result of the decorated parser.
+pub trait MapDecorator<I, C>
+where
+    I: InputTrait,
+{
+    type OriginalOutput;
+    type Output;
+    type Error: ParserErrorTrait;
+
+    /// Gets the decorated parser.
+    fn decorated(
+        &mut self,
+    ) -> &mut impl Parser<I, C, Output = Self::OriginalOutput, Error = Self::Error>;
+
+    /// Maps the successful result of the parser.
+    fn map_ok(&self, ok: Self::OriginalOutput) -> Self::Output;
+}
+
+/// Marker trait for `MapDecorator`.
+/// Allows for blanket trait implementation of `Parser`.
+pub trait MapDecoratorMarker {}
+
+impl<I, C, D> Parser<I, C> for D
+where
+    I: InputTrait,
+    D: MapDecoratorMarker + MapDecorator<I, C>,
+{
+    type Output = D::Output;
+    type Error = D::Error;
+
+    fn parse(&mut self, input: &mut I) -> Result<Self::Output, Self::Error> {
+        match self.decorated().parse(input) {
+            Ok(ok) => Ok(self.map_ok(ok)),
+            Err(err) => Err(err),
+        }
+    }
+
+    fn set_context(&mut self, ctx: &C) {
+        self.decorated().set_context(ctx)
+    }
+}