feat(pc): Support different context type for the inner parser of flatten

Author: ngeor

rusty_parser/src/core/dim_name.rs

@@ -185,9 +185,7 @@ mod type_definition {
                         "Expected: INTEGER or LONG or SINGLE or DOUBLE or STRING or identifier";
                 }
 
-                OrParser::new(parsers)
-                    .with_expected_message(expected_message)
-                    .no_context()
+                OrParser::new(parsers).with_expected_message(expected_message)
             })
             .flatten()
     }

rusty_parser/src/core/opt_second_expression.rs

@@ -75,7 +75,6 @@ pub(super) fn conditionally_opt_whitespace()
             whitespace()
                 .map(Some)
                 .and_then_err(move |err| if allow_none { Ok(None) } else { Err(err) })
-                .no_context()
         })
         .flatten()
 }

rusty_parser/src/core/param_name.rs

@@ -106,9 +106,8 @@ fn extended_type()
                         "Expected: INTEGER or LONG or SINGLE or DOUBLE or STRING or identifier",
                     )
                     .boxed()
-                    .no_context()
             } else {
-                built_in_extended_type().boxed().no_context()
+                built_in_extended_type().boxed()
             }
         })
         .flatten()

rusty_parser/src/core/statements.rs

@@ -92,9 +92,9 @@ fn ctx_demand_separator_p()
     ctx_parser()
         .map(|last_statement_was_comment| {
             if last_statement_was_comment {
-                comment_separator().boxed().no_context()
+                comment_separator().boxed()
             } else {
-                common_separator().boxed().no_context()
+                common_separator().boxed()
             }
         })
         .flatten()

rusty_pc/src/flatten.rs

@@ -1,20 +1,28 @@
+use std::marker::PhantomData;
+
 use crate::{InputTrait, Parser, SetContext};
 
-pub struct FlattenParser<P> {
+pub struct FlattenParser<P, CIn> {
     parser: P,
+    _marker: PhantomData<CIn>,
 }
-impl<P> FlattenParser<P> {
+
+impl<P, CIn> FlattenParser<P, CIn> {
     pub(crate) fn new(parser: P) -> Self {
-        Self { parser }
+        Self {
+            parser,
+            _marker: PhantomData,
+        }
     }
 }
-impl<I, C, P> Parser<I, C> for FlattenParser<P>
+
+impl<I, COut, CIn, P> Parser<I, COut> for FlattenParser<P, CIn>
 where
     I: InputTrait,
-    P: Parser<I, C>,
-    P::Output: Parser<I, C, Error = P::Error>,
+    P: Parser<I, COut>,
+    P::Output: Parser<I, CIn, Error = P::Error>,
 {
-    type Output = <P::Output as Parser<I, C>>::Output;
+    type Output = <P::Output as Parser<I, CIn>>::Output;
     type Error = P::Error;
     fn parse(&mut self, input: &mut I) -> Result<Self::Output, Self::Error> {
         match self.parser.parse(input) {
@@ -23,11 +31,11 @@ where
         }
     }
 }
-impl<C, P> SetContext<C> for FlattenParser<P>
+impl<P, COut, CIn> SetContext<COut> for FlattenParser<P, CIn>
 where
-    P: SetContext<C>,
+    P: SetContext<COut>,
 {
-    fn set_context(&mut self, ctx: C) {
+    fn set_context(&mut self, ctx: COut) {
         self.parser.set_context(ctx)
     }
 }

rusty_pc/src/parser.rs

@@ -154,6 +154,7 @@ where
     // Boxed
     // =======================================================================
 
+    /// Boxes the given parser, erasing its type.
     fn boxed(self) -> BoxedParser<I, C, Self::Output, Self::Error>
     where
         Self: Sized + 'static,
@@ -242,10 +243,15 @@ where
     // Flatten
     // =======================================================================
 
-    fn flatten(self) -> FlattenParser<Self>
+    /// Similar to a flat map operation,
+    /// if the current parser's output is a parser,
+    /// it returns the result of that inner parser.
+    /// Typically used together with ctx_parser and map.
+    /// The context type of the inner parser can be different (`CIn` type).
+    fn flatten<CIn>(self) -> FlattenParser<Self, CIn>
     where
         Self: Sized,
-        Self::Output: Parser<I, C, Error = Self::Error>,
+        Self::Output: Parser<I, CIn, Error = Self::Error>,
     {
         FlattenParser::new(self)
     }