feat: Decouple Parser from ParseError

The `ParseError` type is specific to the QBasic errors.

Decouple the `Parser` trait from it, as that is part of the
generic parser combinator framework.

Author: ngeor

rusty_parser/src/pc/and.rs

@@ -1,4 +1,3 @@
-use crate::error::ParseError;
 use crate::pc::{ParseResult, Parser, ToOption};
 
 //
@@ -12,40 +11,50 @@ where
 {
     /// Parses both the left and the right side.
     /// If the right side fails with a non fatal error, parsing of the left side is undone.
-    fn and<R, F, O>(self, right: R, combiner: F) -> impl Parser<I, Output = O>
+    fn and<R, F, O>(self, right: R, combiner: F) -> impl Parser<I, Output = O, Error = Self::Error>
     where
-        R: Parser<I>,
+        R: Parser<I, Error = Self::Error>,
         F: Fn(Self::Output, R::Output) -> O,
     {
         AndParser::new(self, right, combiner)
     }
 
-    fn and_tuple<R>(self, right: R) -> impl Parser<I, Output = (Self::Output, R::Output)>
+    fn and_tuple<R>(
+        self,
+        right: R,
+    ) -> impl Parser<I, Output = (Self::Output, R::Output), Error = Self::Error>
     where
-        R: Parser<I>,
+        R: Parser<I, Error = Self::Error>,
     {
         self.and(right, |l, r| (l, r))
     }
 
-    fn and_keep_left<R>(self, right: R) -> impl Parser<I, Output = Self::Output>
+    fn and_keep_left<R>(
+        self,
+        right: R,
+    ) -> impl Parser<I, Output = Self::Output, Error = Self::Error>
     where
-        R: Parser<I>,
+        R: Parser<I, Error = Self::Error>,
     {
         self.and(right, |l, _| l)
     }
 
-    fn and_keep_right<R>(self, right: R) -> impl Parser<I, Output = R::Output>
+    fn and_keep_right<R>(self, right: R) -> impl Parser<I, Output = R::Output, Error = Self::Error>
     where
-        R: Parser<I>,
+        R: Parser<I, Error = Self::Error>,
     {
         self.and(right, |_, r| r)
     }
 
     /// Parses the left side and optionally the right side.
     /// The combiner function maps the left and (optional) right output to the final result.
-    fn and_opt<R, F, O>(self, right: R, combiner: F) -> impl Parser<I, Output = O>
+    fn and_opt<R, F, O>(
+        self,
+        right: R,
+        combiner: F,
+    ) -> impl Parser<I, Output = O, Error = Self::Error>
     where
-        R: Parser<I>,
+        R: Parser<I, Error = Self::Error>,
         F: Fn(Self::Output, Option<R::Output>) -> O,
     {
         self.and(right.to_option(), combiner)
@@ -56,35 +65,45 @@ where
     fn and_opt_tuple<R>(
         self,
         right: R,
-    ) -> impl Parser<I, Output = (Self::Output, Option<R::Output>)>
+    ) -> impl Parser<I, Output = (Self::Output, Option<R::Output>), Error = Self::Error>
     where
-        R: Parser<I>,
+        R: Parser<I, Error = Self::Error>,
     {
         self.and_opt(right, |l, r| (l, r))
     }
 
     /// Parses the left side and optionally the right side.
     /// The result is only the left side's output.
-    fn and_opt_keep_left<R>(self, right: R) -> impl Parser<I, Output = Self::Output>
+    fn and_opt_keep_left<R>(
+        self,
+        right: R,
+    ) -> impl Parser<I, Output = Self::Output, Error = Self::Error>
     where
-        R: Parser<I>,
+        R: Parser<I, Error = Self::Error>,
     {
         self.and_opt(right, |l, _| l)
     }
 
     /// Parses the left side and optionally the right side.
     /// The result is only the right side's output.
-    fn and_opt_keep_right<R>(self, right: R) -> impl Parser<I, Output = Option<R::Output>>
+    fn and_opt_keep_right<R>(
+        self,
+        right: R,
+    ) -> impl Parser<I, Output = Option<R::Output>, Error = Self::Error>
     where
-        R: Parser<I>,
+        R: Parser<I, Error = Self::Error>,
     {
         self.and_opt(right, |_, r| r)
     }
 
-    fn surround<L, R>(self, left: L, right: R) -> impl Parser<I, Output = Self::Output>
+    fn surround<L, R>(
+        self,
+        left: L,
+        right: R,
+    ) -> impl Parser<I, Output = Self::Output, Error = Self::Error>
     where
-        L: Parser<I>,
-        R: Parser<I>,
+        L: Parser<I, Error = Self::Error>,
+        R: Parser<I, Error = Self::Error>,
     {
         left.and_keep_right(self).and_keep_left(right)
     }
@@ -120,11 +139,13 @@ impl<I, L, R, F, O> Parser<I> for AndParser<L, R, F>
 where
     I: Clone,
     L: Parser<I>,
-    R: Parser<I>,
+    R: Parser<I, Error = L::Error>,
     F: Fn(L::Output, R::Output) -> O,
 {
     type Output = O;
-    fn parse(&self, tokenizer: I) -> ParseResult<I, Self::Output, ParseError> {
+    type Error = L::Error;
+
+    fn parse(&self, tokenizer: I) -> ParseResult<I, Self::Output, Self::Error> {
         match self.left.parse(tokenizer.clone()) {
             Ok((input, left)) => {
                 match self.right.parse(input) {
@@ -142,11 +163,11 @@ where
 /// Parses the left side optionally and then the right side.
 /// If the right side fails, the left side is reverted too.
 /// The combiner function is used to create the final result.
-pub fn opt_and<I, L, R, F, O>(
-    left: impl Parser<I, Output = L>,
-    right: impl Parser<I, Output = R>,
+pub fn opt_and<I, L, R, E, F, O>(
+    left: impl Parser<I, Output = L, Error = E>,
+    right: impl Parser<I, Output = R, Error = E>,
     combiner: F,
-) -> impl Parser<I, Output = O>
+) -> impl Parser<I, Output = O, Error = E>
 where
     I: Clone,
     F: Fn(Option<L>, R) -> O,
@@ -157,10 +178,10 @@ where
 /// Parses the left side optionally and then the right side.
 /// If the right side fails, the left side is reverted too.
 /// The result is a tuple of the (optional) left side and the right side.
-pub fn opt_and_tuple<I, L, R>(
-    left: impl Parser<I, Output = L>,
-    right: impl Parser<I, Output = R>,
-) -> impl Parser<I, Output = (Option<L>, R)>
+pub fn opt_and_tuple<I, L, R, E>(
+    left: impl Parser<I, Output = L, Error = E>,
+    right: impl Parser<I, Output = R, Error = E>,
+) -> impl Parser<I, Output = (Option<L>, R), Error = E>
 where
     I: Clone,
 {
@@ -170,10 +191,10 @@ where
 /// Parses the left side optionally and then the right side.
 /// If the right side fails, the left side is reverted too.
 /// The result is the right side only, the left is discarded.
-pub fn opt_and_keep_right<I, L, R>(
-    left: impl Parser<I, Output = L>,
-    right: impl Parser<I, Output = R>,
-) -> impl Parser<I, Output = R>
+pub fn opt_and_keep_right<I, L, R, E>(
+    left: impl Parser<I, Output = L, Error = E>,
+    right: impl Parser<I, Output = R, Error = E>,
+) -> impl Parser<I, Output = R, Error = E>
 where
     I: Clone,
 {

rusty_parser/src/pc/boxed.rs

@@ -1,20 +1,22 @@
-use crate::error::ParseError;
 use crate::pc::Parser;
 
-pub fn boxed<I, O>(parser: impl Parser<I, Output = O> + 'static) -> BoxedParser<I, O> {
+pub fn boxed<I, O, E>(
+    parser: impl Parser<I, Output = O, Error = E> + 'static,
+) -> BoxedParser<I, O, E> {
     BoxedParser {
         parser: Box::new(parser),
     }
 }
 
-pub struct BoxedParser<I, O> {
-    parser: Box<dyn Parser<I, Output = O>>,
+pub struct BoxedParser<I, O, E> {
+    parser: Box<dyn Parser<I, Output = O, Error = E>>,
 }
 
-impl<I, O> Parser<I> for BoxedParser<I, O> {
+impl<I, O, E> Parser<I> for BoxedParser<I, O, E> {
     type Output = O;
+    type Error = E;
 
-    fn parse(&self, input: I) -> super::ParseResult<I, Self::Output, ParseError> {
+    fn parse(&self, input: I) -> super::ParseResult<I, Self::Output, Self::Error> {
         self.parser.parse(input)
     }
 }

rusty_parser/src/pc/delimited.rs

@@ -1,4 +1,3 @@
-use crate::error::ParseError;
 use crate::pc::*;
 
 /// Represents a value that has is followed by optional delimiter.
@@ -34,11 +33,15 @@ impl<L, R> Delimited<L> for (L, Option<R>) {
 }
 
 /// Gets a list of items separated by a delimiter.
-pub fn delimited_by<I: Clone, P: Parser<I>, D: Parser<I>>(
+pub fn delimited_by<I, P: Parser<I>, D: Parser<I, Error = P::Error>>(
     parser: P,
     delimiter: D,
-    trailing_error: ParseError,
-) -> impl Parser<I, Output = Vec<P::Output>> {
+    trailing_error: P::Error,
+) -> impl Parser<I, Output = Vec<P::Output>, Error = P::Error>
+where
+    I: Clone,
+    P::Error: Clone + Default,
+{
     parse_delimited_to_items(parser.and_opt_tuple(delimiter), trailing_error)
 }
 
@@ -47,22 +50,19 @@ pub fn delimited_by<I: Clone, P: Parser<I>, D: Parser<I>>(
 /// Public because needed by built_ins to implement csv_allow_missing.
 pub fn parse_delimited_to_items<I: Clone, P, L>(
     parser: P,
-    trailing_error: ParseError,
-) -> impl Parser<I, Output = Vec<L>>
+    trailing_error: P::Error,
+) -> impl Parser<I, Output = Vec<L>, Error = P::Error>
 where
     P: Parser<I>,
     P::Output: Delimited<L>,
+    P::Error: Clone + Default,
 {
     parser
         .loop_while(Delimited::has_delimiter)
         .flat_map(move |input, items| map_items(input, items, trailing_error.clone()))
 }
 
-fn map_items<I, P, T>(
-    input: I,
-    items: Vec<P>,
-    trailing_error: ParseError,
-) -> ParseResult<I, Vec<T>, ParseError>
+fn map_items<I, P, T, E>(input: I, items: Vec<P>, trailing_error: E) -> ParseResult<I, Vec<T>, E>
 where
     P: Delimited<T>,
 {

rusty_parser/src/pc/filter.rs

@@ -1,14 +1,14 @@
-use crate::error::ParseError;
 use crate::pc::{default_parse_error, ParseResult, Parser};
 
 pub trait Filter<I>: Parser<I>
 where
     Self: Sized,
     I: Clone,
 {
-    fn filter<F>(self, predicate: F) -> impl Parser<I, Output = Self::Output>
+    fn filter<F>(self, predicate: F) -> impl Parser<I, Output = Self::Output, Error = Self::Error>
     where
         F: Fn(&Self::Output) -> bool,
+        Self::Error: Default,
     {
         FilterParser(self, predicate)
     }
@@ -27,11 +27,13 @@ impl<I, P, F> Parser<I> for FilterParser<P, F>
 where
     I: Clone,
     P: Parser<I>,
+    P::Error: Default,
     F: Fn(&P::Output) -> bool,
 {
     type Output = P::Output;
+    type Error = P::Error;
 
-    fn parse(&self, tokenizer: I) -> ParseResult<I, Self::Output, ParseError> {
+    fn parse(&self, tokenizer: I) -> ParseResult<I, Self::Output, Self::Error> {
         match self.0.parse(tokenizer.clone()) {
             Ok((input, value)) => {
                 if (self.1)(&value) {

rusty_parser/src/pc/filter_map.rs

@@ -1,12 +1,15 @@
-use crate::error::ParseError;
 use crate::pc::{default_parse_error, ParseResult, ParseResultTrait, Parser};
 
 pub trait FilterMap<I>: Parser<I>
 where
     Self: Sized,
+    Self::Error: Default,
     I: Clone,
 {
-    fn filter_map<F, U>(self, predicate_mapper: F) -> impl Parser<I, Output = U>
+    fn filter_map<F, U>(
+        self,
+        predicate_mapper: F,
+    ) -> impl Parser<I, Output = U, Error = Self::Error>
     where
         F: Fn(&Self::Output) -> Option<U>,
     {
@@ -18,6 +21,7 @@ impl<I, P> FilterMap<I> for P
 where
     I: Clone,
     P: Parser<I>,
+    P::Error: Default,
 {
 }
 
@@ -26,12 +30,13 @@ struct FilterMapParser<P, F>(P, F);
 impl<I: Clone, P, F, U> Parser<I> for FilterMapParser<P, F>
 where
     P: Parser<I>,
-
+    P::Error: Default,
     F: Fn(&P::Output) -> Option<U>,
 {
     type Output = U;
+    type Error = P::Error;
 
-    fn parse(&self, tokenizer: I) -> ParseResult<I, Self::Output, ParseError> {
+    fn parse(&self, tokenizer: I) -> ParseResult<I, Self::Output, Self::Error> {
         self.0
             .parse(tokenizer.clone())
             .flat_map(|input, result| match (self.1)(&result) {

rusty_parser/src/pc/flat_map.rs

@@ -1,14 +1,13 @@
-use crate::error::ParseError;
 use crate::pc::{ParseResult, ParseResultTrait, Parser};
 
 pub trait FlatMap<I>: Parser<I>
 where
     Self: Sized,
 {
     /// Flat map the result of this parser for successful results.
-    fn flat_map<F, U>(self, mapper: F) -> impl Parser<I, Output = U>
+    fn flat_map<F, U>(self, mapper: F) -> impl Parser<I, Output = U, Error = Self::Error>
     where
-        F: Fn(I, Self::Output) -> ParseResult<I, U, ParseError>,
+        F: Fn(I, Self::Output) -> ParseResult<I, U, Self::Error>,
     {
         FlatMapParser(self, mapper)
     }
@@ -21,10 +20,12 @@ struct FlatMapParser<P, F>(P, F);
 impl<I, P, F, U> Parser<I> for FlatMapParser<P, F>
 where
     P: Parser<I>,
-    F: Fn(I, P::Output) -> ParseResult<I, U, ParseError>,
+    F: Fn(I, P::Output) -> ParseResult<I, U, P::Error>,
 {
     type Output = U;
-    fn parse(&self, tokenizer: I) -> ParseResult<I, Self::Output, ParseError> {
+    type Error = P::Error;
+
+    fn parse(&self, tokenizer: I) -> ParseResult<I, Self::Output, Self::Error> {
         self.0.parse(tokenizer).flat_map(&self.1)
     }
 }