add OptionalOrElse Parser

Author: ehwan

README.md

@@ -116,7 +116,7 @@ where
 | `map` | Map the output of the parser | `(T,)` |
 | `repeat` | Repeat the parser multiple times | `(Vec<Output of Self>,)` |
 | `optional` | Success whether the pattern is matched or not | `( Option<Output of Self>, )` |
-| `optional_or` | Success whether the pattern is matched or not | `Output` of `Self` |
+| `optional_or`, `or_else` | Success whether the pattern is matched or not | `Output` of `Self` |
 | `not` | Match for Pattern1 to success and Pattern2 to fail | `Output` of `Self` |
 | `reduce_left`, `reduce_right` | Reduce the output of the parser | `Output` of `Self` |
 | `reduce_with`, `reduce_right_with` | Reduce the output of the parser with initial value | `Init` |
@@ -327,7 +327,7 @@ assert_eq!(res.it.collect::<String>(), "bcd");
 
 
 
-### `optional`, `optional_or`: success whether the pattern is matched or not
+### `optional`, `optional_or`, `or_else`: success whether the pattern is matched or not
 ```rust
 let a_optional_parser = 'a'.optional(); // (Option<char>,)
 
@@ -342,17 +342,21 @@ let a_optional_or = 'a'.optional_or(('x',)); // (char,)
 
 let res = rp::parse(&a_optional_or, "bcd".chars());
 assert_eq!(res.output.unwrap(), ('x',));
+
+// if 'a' failed, evaluate the closure
+let a_or_else = 'a'.or_else( || 'x' ); // (char,)
+assert_eq!(res.output.unwrap(), ('x',));
 ```
 
 `Output` for `optional`:
  - if `Output` of the origin parser is `(T0,)`, `(Option<T0>,)`
  - otherwise, `( Option<Output of Self>, )`
 
- `Output` for `optional_or`:
+ `Output` for `optional_or`, `or_else`:
   - <`Output` of `Self`>. 
 
 #### Note
- - The passed value's type to `optional_or` must match with the `Output` of `Self`
+ - The passed value's type to `optional_or` and `or_else` must match with the `Output` of `Self`
  - For single-value-output ( which's output is `(T,)` ), passing either `T` or `(T,)` is permitted.
 
 

rusty_parser/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rusty_parser"
-version = "1.0.2"
+version = "1.1.0"
 edition = "2021"
 authors = ["ehwan <ehwank98@gmail.com>"]
 description = "A Generic compile-time Parser generator and pattern matching library written in Rust"

rusty_parser/src/core/into_parser.rs

@@ -237,6 +237,38 @@ pub trait IntoParser {
         crate::wrapper::option::OptionalOrParser::new(self.into_parser(), output)
     }
 
+    /// This parser always success whether the input is matched or not.
+    /// If it failed, the given closure will be evaluated and returned.
+    ///
+    /// `Output`:
+    /// <`Output` of Self>.
+    ///
+    /// The value given to `or_else` must match with the `Output` of the origin parser.
+    ///
+    /// For single-value-output ( which's output is `(T,)` ),
+    /// returning either `T` or `(T,)` is permitted.
+    ///
+    /// # Example
+    /// ```rust
+    /// use rusty_parser as rp;
+    /// use rp::IntoParser;
+    ///
+    /// // if 'a' failed, return 'x'
+    /// let a_or_else = 'a'.or_else(|| 'x'); // (char,)
+    ///
+    /// let res = rp::parse(&a_or_else, "bcd".chars());
+    /// assert_eq!(res.output.unwrap(), ('x',));
+    /// ```
+    fn or_else<Closure>(
+        self,
+        closure: Closure,
+    ) -> crate::wrapper::or_else::OptionalOrElseParser<Self::Into, Closure>
+    where
+        Self: Sized,
+    {
+        crate::wrapper::or_else::OptionalOrElseParser::new(self.into_parser(), closure)
+    }
+
     /// Match for parser1 but not parser2.
     ///
     /// `Output`: `Output` of `Self`

rusty_parser/src/wrapper/mod.rs

@@ -5,6 +5,7 @@ pub mod not;
 pub mod notconsume;
 pub mod option;
 pub mod or;
+pub mod or_else;
 pub mod output;
 pub mod rced;
 pub mod reduce;

rusty_parser/src/wrapper/or_else.rs

@@ -0,0 +1,95 @@
+use crate::core::into_parser::IntoParser;
+use crate::core::iterator_bound::InputIteratorTrait;
+use crate::core::parser::Parser;
+use crate::core::result::ParseResult;
+use crate::core::tuple::Tuple;
+use crate::wrapper::tupleutils::singlevalue::SingleValueAutoTuple;
+
+#[derive(Debug, Clone, Copy)]
+pub struct OptionalOrElseParser<Parser, F> {
+    parser: Parser,
+    closure: F,
+}
+
+impl<Parser, F> OptionalOrElseParser<Parser, F> {
+    pub fn new(parser: Parser, closure: F) -> Self {
+        Self { parser, closure }
+    }
+}
+
+impl<ParserA, F, It, FnOutput> Parser<It> for OptionalOrElseParser<ParserA, F>
+where
+    It: InputIteratorTrait,
+    ParserA: Parser<It>,
+    F: Fn() -> FnOutput,
+    FnOutput: SingleValueAutoTuple<ParserA::Output, Output = ParserA::Output>,
+    FnOutput::Output: Tuple,
+{
+    type Output = <ParserA as Parser<It>>::Output;
+
+    fn parse(&self, it: It) -> ParseResult<Self::Output, It> {
+        let res = self.parser.parse(it);
+        if let Some(val) = res.output {
+            return ParseResult {
+                output: Some(val),
+                it: res.it,
+            };
+        }
+        ParseResult {
+            output: Some((self.closure)().wrap()),
+            it: res.it,
+        }
+    }
+
+    fn match_pattern(&self, it: It) -> ParseResult<(), It> {
+        let res = self.parser.match_pattern(it);
+        if res.output.is_some() {
+            ParseResult {
+                output: Some(()),
+                it: res.it,
+            }
+        } else {
+            ParseResult {
+                output: Some(()),
+                it: res.it,
+            }
+        }
+    }
+}
+
+impl<Parser, F> IntoParser for OptionalOrElseParser<Parser, F> {
+    type Into = OptionalOrElseParser<Parser, F>;
+
+    fn into_parser(self) -> Self::Into {
+        self
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::leaf::singlerange::SingleRangeParser;
+    #[test]
+    fn success1() {
+        let digit_parser = SingleRangeParser::from('0'..='9');
+        let digit_or_parser = OptionalOrElseParser::new(digit_parser, || 'a');
+
+        let str = "1a2b3c";
+
+        let res = digit_or_parser.parse(str.chars());
+        assert_eq!(res.output, Some(('1',)));
+        assert_eq!(res.it.as_str(), "a2b3c");
+    }
+
+    #[test]
+    fn success2() {
+        let digit_parser = SingleRangeParser::from('0'..='9');
+        let digit_or_parser = OptionalOrElseParser::new(digit_parser, || 'a');
+
+        let str = "ba2b3c";
+
+        let res = digit_or_parser.parse(str.chars());
+        assert_eq!(res.output, Some(('a',)));
+        assert_eq!(res.it.as_str(), "ba2b3c");
+    }
+}