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

mod common;
mod lexer;
mod parser;

use crate::{
  lexer::lexer_entry,
  parser::{parser_entry_with_recur, parser_entry_with_static},
};
use whitehole::{action::Action, combinator::Combinator, parser::Parser};

const TEXT: &str = r#"
{
  "name": "John Doe",
  "age": 30,
  "is_student": false,
  "scores": [100, 90, 80],
  "address": {
    "city": "New York",
    "zip": "10001"
  }
}
"#;

fn print_all_with_range(
  entry: Combinator<impl Action<Text = str, State = (), Heap = (), Value = ()>>,
) {
  let mut parser = Parser::builder().entry(entry.range()).build(TEXT);

  for output in &mut parser {
    println!(
      "{}..{}: {:?}",
      output.value.range.start,
      output.value.range.end,
      &TEXT[output.value.range.clone()]
    );
  }

  let rest = parser.instant.rest();
  if !rest.is_empty() {
    panic!(
      "failed to consume the whole input, remaining: {:?}",
      &rest[..100.min(rest.len())]
    );
  }
}

fn main() {
  println!("lexer:");
  print_all_with_range(lexer_entry());

  println!("\nparser with recur:");
  print_all_with_range(parser_entry_with_recur());

  println!("\nparser with static:");
  print_all_with_range(parser_entry_with_static());
}

#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn test_json_lexer() {
    print_all_with_range(lexer_entry());
  }

  #[test]
  fn test_json_parser() {
    print_all_with_range(parser_entry_with_recur());
    print_all_with_range(parser_entry_with_static());
  }
}