xrust/parser/combinators/
tuple.rs

1use crate::item::Node;
2use crate::parser::{ParseError, ParseInput, StaticState};
3use qualname::{NamespacePrefix, NamespaceUri};
4
5pub fn tuple2<'a, P1, P2, R1, R2, N: Node, L>(
6    parser1: P1,
7    parser2: P2,
8) -> impl Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, (R1, R2)), ParseError>
9where
10    P1: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R1), ParseError>,
11    P2: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R2), ParseError>,
12    L: FnMut(&NamespacePrefix) -> Result<NamespaceUri, ParseError>,
13{
14    move |input, ss| match parser1(input, ss) {
15        Ok((input1, result1)) => match parser2(input1, ss) {
16            Ok((input2, result2)) => Ok((input2, (result1, result2))),
17            Err(err) => Err(err),
18        },
19        Err(err) => Err(err),
20    }
21}
22
23pub fn tuple3<'a, P1, P2, P3, R1, R2, R3, N: Node, L>(
24    parser1: P1,
25    parser2: P2,
26    parser3: P3,
27) -> impl Fn(
28    ParseInput<'a, N>,
29    &mut StaticState<L>,
30) -> Result<(ParseInput<'a, N>, (R1, R2, R3)), ParseError>
31where
32    P1: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R1), ParseError>,
33    P2: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R2), ParseError>,
34    P3: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R3), ParseError>,
35    L: FnMut(&NamespacePrefix) -> Result<NamespaceUri, ParseError>,
36{
37    move |input, ss| match parser1(input, ss) {
38        Ok((input1, result1)) => match parser2(input1, ss) {
39            Ok((input2, result2)) => match parser3(input2, ss) {
40                Ok((input3, result3)) => Ok((input3, (result1, result2, result3))),
41                Err(err) => Err(err),
42            },
43            Err(err) => Err(err),
44        },
45        Err(err) => Err(err),
46    }
47}
48
49pub fn tuple4<'a, P1, P2, P3, P4, R1, R2, R3, R4, N: Node, L>(
50    parser1: P1,
51    parser2: P2,
52    parser3: P3,
53    parser4: P4,
54    _msg: &str,
55) -> impl Fn(
56    ParseInput<'a, N>,
57    &mut StaticState<L>,
58) -> Result<(ParseInput<'a, N>, (R1, R2, R3, R4)), ParseError>
59where
60    P1: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R1), ParseError>,
61    P2: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R2), ParseError>,
62    P3: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R3), ParseError>,
63    P4: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R4), ParseError>,
64    L: FnMut(&NamespacePrefix) -> Result<NamespaceUri, ParseError>,
65{
66    move |input, ss| match parser1(input, ss) {
67        Ok((input1, result1)) => {
68            /*eprintln!(
69                "tuple4 - {} - step 1 success - remaining input: \"{}\"",
70                msg, input1.0
71            );*/
72            match parser2(input1, ss) {
73                Ok((input2, result2)) => {
74                    /*eprintln!(
75                        "tuple4 - {} - step 2 success - remaining input: \"{}\"",
76                        msg, input2.0
77                    );*/
78                    match parser3(input2, ss) {
79                        Ok((input3, result3)) => {
80                            /*eprintln!(
81                                "tuple4 - {} - step 3 success - remaining input: \"{}\"",
82                                msg, input3.0
83                            );*/
84                            match parser4(input3, ss) {
85                                Ok((input4, result4)) => {
86                                    /*eprintln!(
87                                        "tuple4 - {} - step 4 success - remaining input: \"{}\"",
88                                        msg, input4.0
89                                    );*/
90                                    Ok((input4, (result1, result2, result3, result4)))
91                                }
92                                Err(err) => Err(err),
93                            }
94                        }
95                        Err(err) => Err(err),
96                    }
97                }
98                Err(err) => Err(err),
99            }
100        }
101        Err(err) => Err(err),
102    }
103}
104
105pub(crate) fn tuple5<'a, P1, P2, P3, P4, P5, R1, R2, R3, R4, R5, N: Node, L>(
106    parser1: P1,
107    parser2: P2,
108    parser3: P3,
109    parser4: P4,
110    parser5: P5,
111) -> impl Fn(
112    ParseInput<'a, N>,
113    &mut StaticState<L>,
114) -> Result<(ParseInput<'a, N>, (R1, R2, R3, R4, R5)), ParseError>
115where
116    P1: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R1), ParseError>,
117    P2: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R2), ParseError>,
118    P3: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R3), ParseError>,
119    P4: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R4), ParseError>,
120    P5: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R5), ParseError>,
121    L: FnMut(&NamespacePrefix) -> Result<NamespaceUri, ParseError>,
122{
123    move |input, ss| match parser1(input, ss) {
124        Ok((input1, result1)) => match parser2(input1, ss) {
125            Ok((input2, result2)) => match parser3(input2, ss) {
126                Ok((input3, result3)) => match parser4(input3, ss) {
127                    Ok((input4, result4)) => match parser5(input4, ss) {
128                        Ok((input5, result5)) => {
129                            Ok((input5, (result1, result2, result3, result4, result5)))
130                        }
131                        Err(err) => Err(err),
132                    },
133                    Err(err) => Err(err),
134                },
135                Err(err) => Err(err),
136            },
137            Err(err) => Err(err),
138        },
139        Err(err) => Err(err),
140    }
141}
142
143pub(crate) fn tuple6<'a, P1, P2, P3, P4, P5, P6, R1, R2, R3, R4, R5, R6, N: Node, L>(
144    parser1: P1,
145    parser2: P2,
146    parser3: P3,
147    parser4: P4,
148    parser5: P5,
149    parser6: P6,
150) -> impl Fn(
151    ParseInput<'a, N>,
152    &mut StaticState<L>,
153) -> Result<(ParseInput<'a, N>, (R1, R2, R3, R4, R5, R6)), ParseError>
154where
155    P1: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R1), ParseError>,
156    P2: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R2), ParseError>,
157    P3: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R3), ParseError>,
158    P4: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R4), ParseError>,
159    P5: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R5), ParseError>,
160    P6: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R6), ParseError>,
161    L: FnMut(&NamespacePrefix) -> Result<NamespaceUri, ParseError>,
162{
163    move |input, ss| match parser1(input, ss) {
164        Ok((input1, result1)) => match parser2(input1, ss) {
165            Ok((input2, result2)) => match parser3(input2, ss) {
166                Ok((input3, result3)) => match parser4(input3, ss) {
167                    Ok((input4, result4)) => match parser5(input4, ss) {
168                        Ok((input5, result5)) => match parser6(input5, ss) {
169                            Ok((input6, result6)) => Ok((
170                                input6,
171                                (result1, result2, result3, result4, result5, result6),
172                            )),
173                            Err(err) => Err(err),
174                        },
175                        Err(err) => Err(err),
176                    },
177                    Err(err) => Err(err),
178                },
179                Err(err) => Err(err),
180            },
181            Err(err) => Err(err),
182        },
183        Err(err) => Err(err),
184    }
185}
186
187pub(crate) fn tuple7<'a, P1, P2, P3, P4, P5, P6, P7, R1, R2, R3, R4, R5, R6, R7, N: Node, L>(
188    parser1: P1,
189    parser2: P2,
190    parser3: P3,
191    parser4: P4,
192    parser5: P5,
193    parser6: P6,
194    parser7: P7,
195) -> impl Fn(
196    ParseInput<'a, N>,
197    &mut StaticState<L>,
198) -> Result<(ParseInput<'a, N>, (R1, R2, R3, R4, R5, R6, R7)), ParseError>
199where
200    P1: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R1), ParseError>,
201    P2: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R2), ParseError>,
202    P3: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R3), ParseError>,
203    P4: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R4), ParseError>,
204    P5: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R5), ParseError>,
205    P6: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R6), ParseError>,
206    P7: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R7), ParseError>,
207    L: FnMut(&NamespacePrefix) -> Result<NamespaceUri, ParseError>,
208{
209    move |input, ss| match parser1(input, ss) {
210        Ok((input1, result1)) => match parser2(input1, ss) {
211            Ok((input2, result2)) => match parser3(input2, ss) {
212                Ok((input3, result3)) => match parser4(input3, ss) {
213                    Ok((input4, result4)) => match parser5(input4, ss) {
214                        Ok((input5, result5)) => match parser6(input5, ss) {
215                            Ok((input6, result6)) => match parser7(input6, ss) {
216                                Ok((input7, result7)) => Ok((
217                                    input7,
218                                    (
219                                        result1, result2, result3, result4, result5, result6,
220                                        result7,
221                                    ),
222                                )),
223                                Err(err) => Err(err),
224                            },
225                            Err(err) => Err(err),
226                        },
227                        Err(err) => Err(err),
228                    },
229                    Err(err) => Err(err),
230                },
231                Err(err) => Err(err),
232            },
233            Err(err) => Err(err),
234        },
235        Err(err) => Err(err),
236    }
237}
238
239#[allow(clippy::too_many_arguments)]
240pub(crate) fn tuple8<
241    'a,
242    P1,
243    P2,
244    P3,
245    P4,
246    P5,
247    P6,
248    P7,
249    P8,
250    R1,
251    R2,
252    R3,
253    R4,
254    R5,
255    R6,
256    R7,
257    R8,
258    N: Node,
259    L,
260>(
261    parser1: P1,
262    parser2: P2,
263    parser3: P3,
264    parser4: P4,
265    parser5: P5,
266    parser6: P6,
267    parser7: P7,
268    parser8: P8,
269) -> impl Fn(
270    ParseInput<'a, N>,
271    &mut StaticState<L>,
272) -> Result<(ParseInput<'a, N>, (R1, R2, R3, R4, R5, R6, R7, R8)), ParseError>
273where
274    P1: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R1), ParseError>,
275    P2: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R2), ParseError>,
276    P3: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R3), ParseError>,
277    P4: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R4), ParseError>,
278    P5: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R5), ParseError>,
279    P6: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R6), ParseError>,
280    P7: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R7), ParseError>,
281    P8: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R8), ParseError>,
282    L: FnMut(&NamespacePrefix) -> Result<NamespaceUri, ParseError>,
283{
284    move |input, ss| match parser1(input, ss) {
285        Ok((input1, result1)) => match parser2(input1, ss) {
286            Ok((input2, result2)) => match parser3(input2, ss) {
287                Ok((input3, result3)) => match parser4(input3, ss) {
288                    Ok((input4, result4)) => match parser5(input4, ss) {
289                        Ok((input5, result5)) => match parser6(input5, ss) {
290                            Ok((input6, result6)) => match parser7(input6, ss) {
291                                Ok((input7, result7)) => match parser8(input7, ss) {
292                                    Ok((input8, result8)) => Ok((
293                                        input8,
294                                        (
295                                            result1, result2, result3, result4, result5, result6,
296                                            result7, result8,
297                                        ),
298                                    )),
299                                    Err(err) => Err(err),
300                                },
301                                Err(err) => Err(err),
302                            },
303                            Err(err) => Err(err),
304                        },
305                        Err(err) => Err(err),
306                    },
307                    Err(err) => Err(err),
308                },
309                Err(err) => Err(err),
310            },
311            Err(err) => Err(err),
312        },
313        Err(err) => Err(err),
314    }
315}
316
317#[allow(clippy::too_many_arguments)]
318pub(crate) fn tuple9<
319    'a,
320    P1,
321    P2,
322    P3,
323    P4,
324    P5,
325    P6,
326    P7,
327    P8,
328    P9,
329    R1,
330    R2,
331    R3,
332    R4,
333    R5,
334    R6,
335    R7,
336    R8,
337    R9,
338    N: Node,
339    L,
340>(
341    parser1: P1,
342    parser2: P2,
343    parser3: P3,
344    parser4: P4,
345    parser5: P5,
346    parser6: P6,
347    parser7: P7,
348    parser8: P8,
349    parser9: P9,
350) -> impl Fn(
351    ParseInput<'a, N>,
352    &mut StaticState<L>,
353) -> Result<(ParseInput<'a, N>, (R1, R2, R3, R4, R5, R6, R7, R8, R9)), ParseError>
354where
355    P1: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R1), ParseError>,
356    P2: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R2), ParseError>,
357    P3: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R3), ParseError>,
358    P4: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R4), ParseError>,
359    P5: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R5), ParseError>,
360    P6: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R6), ParseError>,
361    P7: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R7), ParseError>,
362    P8: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R8), ParseError>,
363    P9: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R9), ParseError>,
364    L: FnMut(&NamespacePrefix) -> Result<NamespaceUri, ParseError>,
365{
366    move |input, ss| match parser1(input, ss) {
367        Ok((input1, result1)) => match parser2(input1, ss) {
368            Ok((input2, result2)) => match parser3(input2, ss) {
369                Ok((input3, result3)) => match parser4(input3, ss) {
370                    Ok((input4, result4)) => match parser5(input4, ss) {
371                        Ok((input5, result5)) => match parser6(input5, ss) {
372                            Ok((input6, result6)) => match parser7(input6, ss) {
373                                Ok((input7, result7)) => match parser8(input7, ss) {
374                                    Ok((input8, result8)) => match parser9(input8, ss) {
375                                        Ok((input9, result9)) => Ok((
376                                            input9,
377                                            (
378                                                result1, result2, result3, result4, result5,
379                                                result6, result7, result8, result9,
380                                            ),
381                                        )),
382                                        Err(err) => Err(err),
383                                    },
384                                    Err(err) => Err(err),
385                                },
386                                Err(err) => Err(err),
387                            },
388                            Err(err) => Err(err),
389                        },
390                        Err(err) => Err(err),
391                    },
392                    Err(err) => Err(err),
393                },
394                Err(err) => Err(err),
395            },
396            Err(err) => Err(err),
397        },
398        Err(err) => Err(err),
399    }
400}
401
402#[allow(clippy::too_many_arguments)]
403pub(crate) fn tuple10<
404    'a,
405    P1,
406    P2,
407    P3,
408    P4,
409    P5,
410    P6,
411    P7,
412    P8,
413    P9,
414    P10,
415    R1,
416    R2,
417    R3,
418    R4,
419    R5,
420    R6,
421    R7,
422    R8,
423    R9,
424    R10,
425    N: Node,
426    L,
427>(
428    parser1: P1,
429    parser2: P2,
430    parser3: P3,
431    parser4: P4,
432    parser5: P5,
433    parser6: P6,
434    parser7: P7,
435    parser8: P8,
436    parser9: P9,
437    parser10: P10,
438) -> impl Fn(
439    ParseInput<'a, N>,
440    &mut StaticState<L>,
441) -> Result<(ParseInput<'a, N>, (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)), ParseError>
442where
443    P1: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R1), ParseError>,
444    P2: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R2), ParseError>,
445    P3: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R3), ParseError>,
446    P4: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R4), ParseError>,
447    P5: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R5), ParseError>,
448    P6: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R6), ParseError>,
449    P7: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R7), ParseError>,
450    P8: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R8), ParseError>,
451    P9: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R9), ParseError>,
452    P10: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, R10), ParseError>,
453    L: FnMut(&NamespacePrefix) -> Result<NamespaceUri, ParseError>,
454{
455    move |input, ss| match parser1(input, ss) {
456        Ok((input1, result1)) => match parser2(input1, ss) {
457            Ok((input2, result2)) => match parser3(input2, ss) {
458                Ok((input3, result3)) => match parser4(input3, ss) {
459                    Ok((input4, result4)) => match parser5(input4, ss) {
460                        Ok((input5, result5)) => match parser6(input5, ss) {
461                            Ok((input6, result6)) => match parser7(input6, ss) {
462                                Ok((input7, result7)) => match parser8(input7, ss) {
463                                    Ok((input8, result8)) => match parser9(input8, ss) {
464                                        Ok((input9, result9)) => match parser10(input9, ss) {
465                                            Ok((input10, result10)) => Ok((
466                                                input10,
467                                                (
468                                                    result1, result2, result3, result4, result5,
469                                                    result6, result7, result8, result9, result10,
470                                                ),
471                                            )),
472                                            Err(err) => Err(err),
473                                        },
474                                        Err(err) => Err(err),
475                                    },
476                                    Err(err) => Err(err),
477                                },
478                                Err(err) => Err(err),
479                            },
480                            Err(err) => Err(err),
481                        },
482                        Err(err) => Err(err),
483                    },
484                    Err(err) => Err(err),
485                },
486                Err(err) => Err(err),
487            },
488            Err(err) => Err(err),
489        },
490        Err(err) => Err(err),
491    }
492}
493
494#[cfg(test)]
495mod tests {
496    use crate::parser::combinators::tag::tag;
497    use crate::parser::combinators::tuple::tuple3;
498    use crate::parser::{ParseError, ParserState, StaticStateBuilder};
499    use crate::trees::nullo::Nullo;
500    use qualname::NamespaceUri;
501
502    #[test]
503    fn parser_tuple3_test1() {
504        let testdoc = "<doc>";
505        let teststate: ParserState<Nullo> = ParserState::new();
506        let mut static_state = StaticStateBuilder::new()
507            .namespace(|_| {
508                NamespaceUri::try_from("urn:xrust").map_err(|_| ParseError::MissingNameSpace)
509            })
510            .build();
511        let parse_doc = tuple3(tag("<"), tag("doc"), tag(">"));
512        assert_eq!(
513            Ok((("", ParserState::new()), ((), (), ()))),
514            parse_doc((testdoc, teststate), &mut static_state)
515        );
516    }
517}
xrust/parser/combinators/tuple.rs

xrust/parser/combinators/
tuple.rs
