peggen-core 0.2.0

Generate recursive-descent & precedence climbing parsers. (traits)
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

use crate::*;
use core::{fmt::Debug, ops::{Deref, Range}};

/// Annoted value
#[derive(Debug, Clone)]
pub struct Span<X> {
    pub value: X,
    pub range: Range<usize>,
}

pub trait ToSpan: Sized {
    fn span(self, range: core::ops::Range<usize>) -> Span<Self>;
}

impl<X> ToSpan for X {
    fn span(self, range: core::ops::Range<usize>) -> Span<Self> {
        Span { value: self, range }
    }
}

impl<X> Span<X> {
    pub fn map<Y>(self, f: impl FnOnce(X) -> Y) -> Span<Y> {
        Span { value: f(self.value), range: self.range }
    }
}

impl<X> Span<X> {
    pub fn inner_ref<Y: ?Sized>(&self) -> Span<&Y> where X: AsRef<Y> {
        Span { value: self.value.as_ref(), range: self.range.clone() }
    }
}

impl<X> Deref for Span<X> {
    type Target = X;
    fn deref(&self) -> &Self::Target {
        &self.value
    }
}

impl<const GROUP: usize, const ERROR: bool, T> ParseImpl<GROUP, ERROR> for Span<T> 
    where T: ParseImpl<GROUP, ERROR>
{
    fn parse_impl(
        input: &str, end: usize,
        trace: &mut Vec<(usize, usize)>,
        stack: &mut Vec<Tag>,
    ) -> Result<usize, ()> {
        <T as ParseImpl<GROUP, ERROR>>::parse_impl(input, end, trace, stack)
    }
}

impl<Extra, T> AstImpl<Extra> for Span<T> 
    where T: AstImpl<Extra>,
            Extra: Copy,
{
    fn ast<'a>(
        input: &'a str, 
        stack: &'a [Tag], 
        with: Extra
    ) -> (&'a [Tag], Self) {
        let range = stack[stack.len()-1].span.clone();
        let (rest, value) = T::ast(input, stack, with);
        (rest, Span { value, range })
    }
}