xrust/parser/combinators/
alt.rs

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

xrust/parser/combinators/
alt.rs
