parsa 1.1.1

a functional combinator 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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use crate::{combinators::*, ParserString};

use paste::paste;

macro_rules! delegate {
    (
        [$($dec_gen:ident $(: $rest:ty)?),*] //generics
        $name: ident<$($s_gen:ty),*>, //struct
        (self, $($arg:ident: $arg_ty: ty),*)) => { //arg
    paste! {
        #[doc = concat!("Constructs a [`", stringify!($name), "`] combinator.")] 
        fn [<$name:snake>]<$($dec_gen $(: $rest)?),*>(self, $($arg:$arg_ty),*) -> $name<$($s_gen),*> {
            $name::new(self, $($arg),*)
        } 
    } 
    };
}


///All parsers implement this trait. Any function or closure with the signature 
///`Fn(&mut ParserString) -> Result<T, E>` implements Parser.
pub trait Parser<T>: Sized {
    ///The error type this parser can return
    type Err;
    ///Run this parser, using a [`ParserString`].
    fn parse(&self, s: &mut ParserString) -> Result<T, Self::Err>;

    ///Run this parser without affecting the string on failure. In other words, the string will be
    ///"rewinded" on failure.
    fn try_parse(&self, s: &mut ParserString) -> Result<T, Self::Err> {
        let i = s.start();
        self.parse(s).map_err(|err| {
            unsafe { s.set_ptr(i) };
            err
        })
    }

    delegate! {
        [U, P2: Parser<U, Err = E>, E: Into<Self::Err>] 
        Chain<T, U, Self, P2>, 
        (self, other: P2)
    } 

    delegate! {
        [P2: Parser<T, Err = E>, E: Into<Self::Err>]
        Or<T, E, Self, P2>, 
        (self, other: P2)
    }

    delegate! {
        []
        Many<T, Self>,
        (self, )
    }
    delegate! {
        []
        Many1<T, Self>,
        (self, )
    }

    ///Apply a function to the output of this parser on success.
    fn map<U: 'static>(self, f: impl Fn(T) -> U + 'static) -> impl Parser<U, Err = Self::Err> {
        move |s: &mut ParserString| {
            self.parse(s).map(&f)
        }
    }
    ///Apply a function to the [`Err`] output of this parser on failure.
    fn map_err<E: 'static>(self, f: impl Fn(Self::Err) -> E + 'static) -> impl Parser<T, Err = E> {
        move |s: &mut ParserString| {
            self.parse(s).map_err(&f)
        }
    }
    ///Applies a function to the output of this parser on success, using [error coercion rules](crate::combinators#error-coercion-rules).
    fn and_then<U: 'static, E: Into<Self::Err>>(self, f: impl Fn(T) -> Result<U, E> + 'static) -> impl Parser<U, Err = Self::Err> {
        move |s: &mut ParserString| -> Result<U, Self::Err> {
            match self.parse(s) {
                Ok(v) => f(v).map_err(Into::into),
                Err(e) => Err(e),
            }
        }
    }

    ///Similar to [`Chain`], but only keeps the output of the first parser.
    fn after<U, P2: Parser<U, Err = E>, E: Into<Self::Err>>(self, other: P2) -> impl Parser<T, Err = Self::Err> {
        let p = self.chain(other);
        move |s: &mut ParserString| {
            p.parse(s).map(|(x, _)| x)
        }
    }

    ///Similar to [`Chain`], but only keeps the output of the second parser.
    fn replace<U, P2: Parser<U, Err = E>, E: Into<Self::Err>>(self, other: P2) -> impl Parser<U, Err = Self::Err> {
        let p = self.chain(other);
        move |s: &mut ParserString| {
            p.parse(s).map(|(_, x)| x)
        }
    }

    ///Explicitly sets the target error type of this parser. Can help with type inference.
    fn convert_err<E: From<Self::Err> + 'static>(self) -> impl Parser<T, Err = E> {
        self.map_err(|e| e.into())
    }
}

///Parse an instance of this type, Similar to [`FromStr`].
pub trait Parsable: Sized {
    ///The error type this parser can return
    type Err;
    ///Run this parser, using a [`ParserString`].
    fn parse(s: &mut ParserString) -> Result<Self, Self::Err>;

    ///Run this parser without affecting the string on failure. In other words, the string will be
    ///"rewinded" on failure.
    fn try_parse(s: &mut ParserString) -> Result<Self, Self::Err> {
        Self::parse.try_parse(s)
    }
}

impl<T, E, F: Fn(&mut ParserString) -> Result<T, E>> Parser<T> for F {
    type Err = E;
    fn parse(&self, s: &mut ParserString) -> Result<T, Self::Err> {
        self(s)
    }
}