binator_utils 0.0.0

This contains utils combinator for binator
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

use core::ops::{
  FromResidual,
  Try,
};

use binator_core::{
  Contexting,
  Parse,
  Parsed,
  Streaming,
};

use crate::UtilsAtom;

/// Implementation of [crate::Utils::try_fold_until]
#[derive(Clone)]
pub struct TryFoldUntil<Parser, Until, Init, F> {
  parser: Parser,
  until: Until,
  init: Init,
  f: F,
}

/// Function style version of [crate::Utils::try_fold_until]
pub fn try_fold_until<Stream, Context, Acc, Parser, Until, Init, Ret, F>(
  parser: Parser, until: Until, init: Init, f: F,
) -> TryFoldUntil<Parser, Until, Init, F>
where
  Stream: Streaming,
  Context: Contexting<UtilsAtom<Stream>>,
  Parser: Parse<Stream, Context>,
  Until: Parse<Stream, Context>,
  Init: Fn() -> Ret,
  F: Fn(Acc, Parser::Token) -> Ret,
  Ret: Try<Output = Acc>,
  Parsed<(Acc, Until::Token), Stream, Context>: FromResidual<Ret::Residual>,
{
  TryFoldUntil {
    parser,
    until,
    init,
    f,
  }
}

impl<Stream, Context, Acc, Parser, Until, Init, Ret, F> Parse<Stream, Context>
  for TryFoldUntil<Parser, Until, Init, F>
where
  Stream: Streaming,
  Context: Contexting<UtilsAtom<Stream>>,
  Parser: Parse<Stream, Context>,
  Until: Parse<Stream, Context>,
  Init: Fn() -> Ret,
  F: Fn(Acc, Parser::Token) -> Ret,
  Ret: Try<Output = Acc>,
  Parsed<(Acc, Until::Token), Stream, Context>: FromResidual<Ret::Residual>,
{
  type Token = (Acc, Until::Token);

  fn parse(&mut self, mut stream: Stream) -> Parsed<Self::Token, Stream, Context> {
    let mut acc = (self.init)()?;
    loop {
      match self.until.parse(stream.clone()) {
        Parsed::Success { token, stream } => {
          break Parsed::Success {
            token: (acc, token),
            stream,
          };
        }
        Parsed::Failure(until_context) => match self.parser.parse(stream) {
          Parsed::Success {
            token,
            stream: next,
          } => {
            acc = (self.f)(acc, token)?;
            stream = next;
          }
          Parsed::Failure(context) => {
            break Parsed::Failure(context.bitor(until_context).add(UtilsAtom::UntilNotReach));
          }
          Parsed::Error(context) => {
            break Parsed::Error(context);
          }
        },
        Parsed::Error(context) => {
          break Parsed::Error(context);
        }
      }
    }
  }
}

#[cfg(test)]
mod tests {}