Add loop_parser

Author: uzytkownik

src/parser/sequence.rs

@@ -891,3 +891,125 @@ where
 {
     ThenRef(p, f)
 }
+
+#[derive(Copy, Clone)]
+pub struct Loop<F, S>(F, S);
+
+impl<Input, F, P, G, S> Parser<Input> for Loop<F, S>
+where
+    Input: Stream,
+    F: FnMut(&mut S) -> P,
+    P: Parser<Input, Output = G>,
+    G: FnOnce(&mut S),
+    S: Clone
+{
+    type Output = S;
+    type PartialState = (Option<S>, Option<P>, bool, P::PartialState);
+
+    parse_mode!(Input);
+    #[inline]
+    fn parse_mode_impl<M>(
+        &mut self,
+        mut mode: M,
+        input: &mut Input,
+        state: &mut Self::PartialState,
+    ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
+    where
+        M: ParseMode,
+    {
+        let Self(ref mut next_func, ref init_state) = *self;
+        let (ref mut state, ref mut parser, ref mut committed, ref mut partial_state) = *state;
+        if mode.is_first() {
+            debug_assert!(state.is_none());
+            debug_assert!(parser.is_none());
+            debug_assert!(!*committed);
+            *state = Some(init_state.clone());
+            *parser = Some(next_func(state.as_mut().unwrap()));
+        }
+        let parser = parser.as_mut().unwrap();
+        loop {
+            let before = input.checkpoint();
+            let result = parser.parse_mode_impl(mode, input, partial_state);
+            let mutator = match result {
+                CommitOk(next_mutator) => {
+                    *committed = true;
+                    next_mutator
+                },
+                PeekOk(next_mutator) => next_mutator,
+                CommitErr(e) => return CommitErr(e),
+                PeekErr(_) => {
+                    match input.reset(before) {
+                        Ok(_) => if *committed {
+                            return CommitOk(state.take().unwrap())
+                        } else {
+                            return PeekOk(state.take().unwrap())
+                        },
+                        Err(err) => return CommitErr(err)
+                    };
+                }
+            };
+            let state = state.as_mut().unwrap();
+            mutator(state);
+            *parser = next_func(state);
+            *partial_state = Default::default();
+            mode.set_first();
+        }
+    }
+}
+
+
+// If `init` is not `None` it parses using it first. Than subsequently
+// applies `func` to result until `None` is returned. The result is
+// the last state.
+//
+// Otherwise, if `init` is `None`, it returns the `state` without
+// consuming any input.
+//
+/// ```
+/// # extern crate combine;
+/// # use std::collections::HashMap;
+/// # use combine::{Parser, Stream, many1, token, value, unexpected_any, optional, choice};
+/// # use combine::parser::char::digit;
+/// # use combine::parser::sequence::loop_parser;
+/// # fn main() {
+/// // Parses 'a', 'b' and 'c' such that there is no consecutive letters returning their count
+/// #[derive(PartialEq, Eq, Clone, Hash)]
+/// enum Token { A, B, C }
+/// fn token_parser<Input>(last_token: &Option<Token>) -> impl Parser<Input, Output = Token>
+/// where
+///     Input: Stream<Token = char>
+/// {
+///     let mut choices = vec![];
+///     if *last_token != Some(Token::A) {
+///         choices.push(token('a').map(|_| Token::A).left());
+///     }
+///     if *last_token != Some(Token::B) {
+///         choices.push(token('b').map(|_| Token::B).left().right());
+///     }
+///     if *last_token != Some(Token::C) {
+///         choices.push(token('c').map(|_| Token::C).right().right());
+///     }
+///     choice(choices)
+/// }
+/// let result = loop_parser((HashMap::<Token, usize>::new(), None), |(_, last_token)| {
+///     token_parser(last_token).map(|current_token| move |(ref mut acc, ref mut last_token): &mut (HashMap::<Token, usize>, Option<Token>)| {
+///         *acc.entry(current_token.clone()).or_insert(0) += 1;
+///         *last_token = Some(current_token);
+///     })
+/// }).map(|x| x.0).parse("ababacbcbcaa");
+/// assert_eq!(result.as_ref().map(|x| x.0.get(&Token::A)), Ok(Some(&4)));
+/// assert_eq!(result.as_ref().map(|x| x.0.get(&Token::B)), Ok(Some(&4)));
+/// assert_eq!(result.as_ref().map(|x| x.0.get(&Token::C)), Ok(Some(&3)));
+/// assert_eq!(result.as_ref().map(|x| x.1), Ok("a"));
+/// # }
+/// ```
+pub fn loop_parser<Input, F, P, G, S>(state: S, func: F) -> Loop<F, S>
+where
+    Input: Stream,
+    F: FnMut(&mut S) -> P,
+    P: Parser<Input, Output = G>,
+    G: FnOnce(&mut S),
+    S: Clone
+{
+    Loop(func, state)
+}