peresil 0.3.0

A simple and simplistic string parsing library
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

//! # Simplistic sentence parser
//!
//! This example shows how parsing can be split into separate
//! tokenization and parsing steps.
//!
//! ## Grammar
//!
//! Document := Sentence* ε
//! Sentence := Article S Noun S Verb "."
//! Article  := "a" | "the"
//! Noun     := "dog" | "cat" | "bird"
//! Verb     := "runs" | "eats" | "sleeps"
//! S        := " "+

#[macro_use]
extern crate peresil;

use peresil::v2::{self, ParseMaster, StringPoint};

#[derive(Debug,Copy,Clone,PartialEq)]
enum Article { A, The }
#[derive(Debug,Copy,Clone,PartialEq)]
enum Noun { Dog, Cat, Bird }
#[derive(Debug,Copy,Clone,PartialEq)]
enum Verb { Runs, Eats, Sleeps }

#[derive(Debug,Copy,Clone,PartialEq)]
struct Sentence {
    article: Article,
    noun: Noun,
    verb: Verb,
}

#[derive(Debug,Copy,Clone,PartialEq)]
enum Error {}

type TokenMaster<'a> = ParseMaster<StringPoint<'a>, Error>;
type TokenProgress<'a, T> = v2::Progress<StringPoint<'a>, T, Error>;

fn consume_article<'a>(pm: &mut TokenMaster<'a>, pt: StringPoint<'a>) -> TokenProgress<'a, Article> {
    v2::Progress::failure()
}

fn consume_noun<'a>(pm: &mut TokenMaster<'a>, pt: StringPoint<'a>) -> TokenProgress<'a, Article> {
    v2::Progress::failure()
}

fn consume_verb<'a>(pm: &mut TokenMaster<'a>, pt: StringPoint<'a>) -> TokenProgress<'a, Article> {
    v2::Progress::failure()
}

fn consume_article<'a>(pm: &mut TokenMaster<'a>, pt: StringPoint<'a>) -> TokenProgress<'a, Article> {
    v2::Progress::failure()
}

fn consume_article<'a>(pm: &mut TokenMaster<'a>, pt: StringPoint<'a>) -> TokenProgress<'a, Article> {
    v2::Progress::failure()
}

fn consume_article<'a>(pm: &mut TokenMaster<'a>, pt: StringPoint<'a>) -> TokenProgress<'a, Article> {
    v2::Progress::failure()
}

fn tokenize(s: &str) {
    let mut pm = ParseMaster::new();
    let pt = StringPoint::new(s);

    pm.zero_or_more(pt, |pm, pt| {
        pm.alternate()
            .one(|pm| consume_article(pm, pt))
            .one(|pm| consume_noun(pm, pt))
            .one(|pm| consume_verb(pm, pt))
            .one(|pm| consume_full_stop(pm, pt))
            .one(|pm| consume_whitespace(pm, pt))
            .one(|pm| consume_end_of_input(pm, pt))
            .finish()
    })
}

fn parse(s: &str) -> Result<Vec<Sentence>, (usize, Vec<Error>)> {
    let tokens = tokenize(s);
    Err((0, vec![]))
}

#[test]
fn a() {
    assert_eq!(
        parse("the dog runs."),
        Ok(vec![Sentence { article: Article::The, noun: Noun::Dog, verb: Verb::Runs }])
    );
}