whitehole 0.8.0

A simple, fast, intuitive parser combinator framework for Rust.
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
95

use std::{fmt::Debug, ops::RangeTo, slice::SliceIndex};
use whitehole::{
  action::{Action, Input, Output},
  combinator::{eat, Combinator},
  digest::Digest,
  instant::Instant,
  parser::Parser,
};

// Define a trait to extend the combinator.

// The simpler way: return `impl`.

trait SimpleCombinatorExt<T: Action, Text: ?Sized> {
  /// Create a new combinator to print the range and content if accepted.
  fn simple_print(
    self,
  ) -> Combinator<impl Action<Text = Text, State = T::State, Heap = T::Heap, Value = T::Value>>;
}

impl<T: Action<Text = Text>, Text: ?Sized + Debug + Digest> SimpleCombinatorExt<T, Text>
  for Combinator<T>
where
  RangeTo<usize>: SliceIndex<Text, Output = Text>,
{
  fn simple_print(
    self,
  ) -> Combinator<impl Action<Text = Text, State = T::State, Heap = T::Heap, Value = T::Value>> {
    self.then(|accept| {
      println!(
        "{}..{}: {:?}",
        accept.start(),
        accept.end(),
        accept.content()
      )
    })
  }
}

// The more complex way: use a custom struct.

struct Print<T> {
  action: T,
}

trait CombinatorExt<T> {
  /// Create a new combinator to print the range and content if accepted.
  fn print(self) -> Combinator<Print<T>>;
}

impl<T> CombinatorExt<T> for Combinator<T> {
  fn print(self) -> Combinator<Print<T>> {
    Combinator::new(Print {
      action: self.action,
    })
  }
}

unsafe impl<T: Action<Text: Digest + Debug>> Action for Print<T>
where
  RangeTo<usize>: SliceIndex<T::Text, Output = T::Text>,
{
  type Text = T::Text;
  type State = T::State;
  type Heap = T::Heap;
  type Value = T::Value;

  fn exec(
    &self,
    mut input: Input<&Instant<&Self::Text>, &mut Self::State, &mut Self::Heap>,
  ) -> Option<Output<Self::Value>> {
    self.action.exec(input.reborrow()).inspect(|output| {
      let start = input.instant.digested();
      let end = start + output.digested;
      println!(
        "{}..{}: {:?}",
        start,
        end,
        input.instant.rest().get(..output.digested)
      );
    })
  }
}

fn main() {
  Parser::builder()
    .entry(eat("hello").simple_print())
    .build("hello world")
    .next();

  Parser::builder()
    .entry(eat("hello").print())
    .build("hello world")
    .next();
}