teleparse 0.1.2

teleparse
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

#[doc(hidden)]
macro_rules! derive_tuple_production {
    ($e1:tt, $($e:tt),*) => {
const _: () = {
    use $crate::syntax::Production;
    #[automatically_derived]
    impl<
        $e1: Production,
        $($e: Production<L=<$e1 as $crate::syntax::Production>::L>,)*
    > Production for ($e1, $($e),*)
    {
        type L = <$e1 as Production>::L;
        fn debug() -> ::std::borrow::Cow<'static, str> {
            let mut s = ::std::string::String::new();
            s.push_str(&<$e1>::debug());
        $(
            s.push(' ');
            s.push_str(&<$e>::debug());
        )*
            ::std::borrow::Cow::Owned(s)
        }
        fn register(meta: &mut $crate::syntax::MetadataBuilder<Self::L>) {
            $crate::register_sequence!(meta, $e1, $( $e ),*);
        }
    }
    impl<L: $crate::lex::Lexicon,
        $e1: $crate::parser::Produce,
        $($e: $crate::parser::Produce,)*
    > $crate::parser::Produce for ($e1, $($e,)*)
    where
        <$e1 as $crate::parser::Produce>::Prod: Production<L=L>,
        $(<$e as $crate::parser::Produce>::Prod: Production<L=L>,)*
    {
        type Prod = (<$e1>::Prod, $(<$e>::Prod,)*);

        fn produce(
            parser: &mut $crate::parser::Parser<'_, <Self::Prod as Production>::L>,
            meta: &$crate::syntax::Metadata<<Self::Prod as Production>::L>,
        ) -> $crate::syntax::Result<Self, <Self::Prod as Production>::L> {
            let mut errors = ::std::vec::Vec::new();
            let result = (
            $crate::handle_result!(errors, <$e1>::produce(parser, meta)),
        $(
            $crate::handle_result!(errors, <$e>::produce(parser, meta))
        ),*
            );
            (result, errors).into()
        }
    }
};

    }
}

derive_tuple_production!(A, B);
derive_tuple_production!(A, B, C);
derive_tuple_production!(A, B, C, D);
derive_tuple_production!(A, B, C, D, E);

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

    use crate::lex::Token;
    use crate::test::MathTokenType as T;
    use crate::test::{Ident, OpAdd, OpMul};

    #[derive_syntax]
    #[teleparse(root)]
    #[derive(Debug, PartialEq)]
    struct Tuple2(Ident, Ident);

    #[test]
    fn parse_tuple_2() {
        let t = Tuple2::parse("a b").unwrap().unwrap();
        assert_eq!(
            t,
            Tuple2(
                Ident(Token::new((0, 1), T::Ident)),
                Ident(Token::new((2, 3), T::Ident)),
            )
        );

        let t = Tuple2::parse("+").unwrap();
        assert!(t.is_none());

        let t = Tuple2::parse("a b c").unwrap().unwrap();
        assert_eq!(
            t,
            Tuple2(
                Ident(Token::new((0, 1), T::Ident)),
                Ident(Token::new((2, 3), T::Ident)),
            )
        );
    }

    #[derive_syntax]
    #[teleparse(root)]
    #[derive(Debug, PartialEq)]
    struct Tuple3(Ident, OpAdd, Ident);

    #[test]
    fn parse_tuple_3() {
        let t = Tuple3::parse("a+b").unwrap().unwrap();
        assert_eq!(
            t,
            Tuple3(
                Ident(Token::new((0, 1), T::Ident)),
                OpAdd(Token::new((1, 2), T::Op)),
                Ident(Token::new((2, 3), T::Ident)),
            )
        );
    }

    #[derive_syntax]
    #[teleparse(root)]
    #[derive(Debug, PartialEq)]
    struct Nested {
        a: (Ident, OpMul, Ident),
        op: OpAdd,
        b: (Ident, OpMul, Ident),
    }

    #[test]
    fn parse_nested() {
        let t = Nested::parse("a*b + c*d").unwrap().unwrap();
        assert_eq!(
            t,
            Nested {
                a: (
                    Ident(Token::new((0, 1), T::Ident)),
                    OpMul(Token::new((1, 2), T::Op)),
                    Ident(Token::new((2, 3), T::Ident)),
                ),
                op: OpAdd(Token::new((4, 5), T::Op)),
                b: (
                    Ident(Token::new((6, 7), T::Ident)),
                    OpMul(Token::new((7, 8), T::Op)),
                    Ident(Token::new((8, 9), T::Ident)),
                ),
            }
        );
    }
}