xparse/
ops.rs

1use crate::{
2    parse::{macros::impl_parse, ParseImpl},
3    Concat, Error, HardError, Result, SourceBase,
4};
5use alloc::vec::Vec;
6use core::{borrow::Borrow, marker::PhantomData, ops::Range};
7
8pub trait Const {
9    type Type;
10    const VALUE: Self::Type;
11}
12
13pub trait Predicate<T, A> {
14    fn is(v: &T, a: &A) -> bool;
15}
16
17pub trait Mapper<T, A> {
18    type Output;
19    fn map(v: T, a: &A) -> Self::Output;
20}
21
22pub struct Define<T>(PhantomData<T>);
23
24impl<T, U: Mapper<T, A>, A> Mapper<T, A> for Define<U> {
25    type Output = U::Output;
26    #[inline(always)]
27    fn map(v: T, a: &A) -> Self::Output {
28        U::map(v, a)
29    }
30}
31
32impl<T, U: Predicate<T, A>, A> Predicate<T, A> for Define<U> {
33    #[inline(always)]
34    fn is(v: &T, arg: &A) -> bool {
35        U::is(v, arg)
36    }
37}
38
39impl<T: Const> Const for Define<T> {
40    type Type = T::Type;
41    const VALUE: Self::Type = T::VALUE;
42}
43
44impl<I, U: ParseImpl<I, A>, A> ParseImpl<I, A> for Define<U> {
45    type Output = U::Output;
46
47    #[inline(always)]
48    fn parse<S: crate::Source<Item = I>>(input: &mut S, arg: &A) -> Result<Self::Output> {
49        U::parse(input, arg)
50    }
51
52    #[cfg(feature = "async")]
53    #[inline(always)]
54    async fn parse_async<S: crate::AsyncSource<Item = I>>(
55        input: &mut S,
56        arg: &A,
57    ) -> Result<Self::Output> {
58        U::parse_async(input, arg).await
59    }
60}
61
62pub struct Is<P>(PhantomData<P>);
63
64impl<I: Clone, P: Predicate<I, A>, A> ParseImpl<I, A> for Is<P> {
65    type Output = (I,);
66    impl_parse!(parse, _await, |input: I, arg: A| {
67        if let Some(item) = _await!(input.read(1))?.first() {
68            if P::is(item, arg) {
69                let item = item.clone();
70                input.consume(1);
71                return Ok((item,));
72            }
73        }
74
75        Err(Error::Mismatch)
76    });
77}
78
79impl<I, P: Predicate<I, A>, A> Predicate<I, A> for Is<P> {
80    #[inline(always)]
81    fn is(v: &I, arg: &A) -> bool {
82        P::is(v, arg)
83    }
84}
85
86pub type A<C> = AnyOf<AsMany<C>>;
87
88pub struct Not<T>(PhantomData<T>);
89
90impl<I, T: Predicate<I, A>, A> Predicate<I, A> for Not<T> {
91    #[inline(always)]
92    fn is(v: &I, arg: &A) -> bool {
93        !T::is(v, arg)
94    }
95}
96
97impl<I: Clone, T: Predicate<I, A>, A> ParseImpl<I, A> for Not<T> {
98    type Output = <Is<Self> as ParseImpl<I, A>>::Output;
99    impl_parse!(parse, _await, |input: I, arg: A| parse!(
100        Is::<Self>, input, arg
101    ));
102}
103
104pub type AsMany<T> = ConstSome<T>;
105
106pub struct ConstSome<T>(PhantomData<T>);
107
108impl<T: Const> Const for ConstSome<T> {
109    type Type = Option<T::Type>;
110    const VALUE: Self::Type = Some(T::VALUE);
111}
112
113pub struct ConstNone<T>(PhantomData<T>);
114
115impl<T> Const for ConstNone<T> {
116    type Type = Option<T>;
117    const VALUE: Self::Type = None;
118}
119
120pub struct ConstUSize<const VALUE: usize>;
121
122impl<const VALUE: usize> Const for ConstUSize<VALUE> {
123    type Type = usize;
124    const VALUE: Self::Type = VALUE;
125}
126
127pub struct AnyOf<C>(PhantomData<C>);
128
129impl<C: Const<Type = G>, G: IntoIterator<Item = T>, T: Borrow<U>, U: PartialEq, A> Predicate<U, A>
130    for AnyOf<C>
131{
132    #[inline(always)]
133    fn is(v: &U, _: &A) -> bool {
134        C::VALUE.into_iter().any(|x| v == x.borrow())
135    }
136}
137
138impl<C: Const<Type = G>, G: IntoIterator<Item = T>, T: Borrow<U>, U: PartialEq + Clone, A>
139    ParseImpl<U, A> for AnyOf<C>
140{
141    type Output = <Is<Self> as ParseImpl<U, A>>::Output;
142    impl_parse!(parse, _await, |input: U, _arg: A| parse!(
143        Is::<Self>,
144        input,
145        &()
146    ));
147}
148
149pub struct Seq<C>(PhantomData<C>);
150
151impl<C: Const<Type = G>, G: IntoIterator<Item = T>, T: Borrow<I>, I: PartialEq + Clone, A>
152    ParseImpl<I, A> for Seq<C>
153{
154    type Output = (Vec<I>,);
155    impl_parse!(parse, _await, |input: I, _arg: A| {
156        let i = C::VALUE.into_iter();
157        let mut count = 0;
158        for item in i {
159            match _await!(input.read(count + 1))?.get(count) {
160                Some(read) if read == item.borrow() => {
161                    count += 1;
162                }
163                _ => return Err(Error::Mismatch),
164            }
165        }
166        let result = _await!(input.read(count))?.to_vec();
167        input.consume(count);
168        Ok((result,))
169    });
170}
171
172pub struct Discard<T = NoOp>(PhantomData<T>);
173
174pub struct NoOp<T = ()>(PhantomData<T>);
175
176pub struct Never<T>(PhantomData<T>);
177
178impl<I, T: ParseImpl<I, A>, A> ParseImpl<I, A> for Discard<T> {
179    type Output = ();
180    impl_parse!(parse, _await, |input: I, arg: A| {
181        parse!(T, input, arg)?;
182        Ok(())
183    });
184}
185
186impl<I, A, T: Default> ParseImpl<I, A> for NoOp<T> {
187    type Output = T;
188    impl_parse!(parse, _await, |__: I, _arg: A| Ok(T::default()));
189}
190
191impl<T, A> Mapper<(T,), A> for NoOp {
192    type Output = T;
193    #[inline(always)]
194    fn map((v,): (T,), _: &A) -> Self::Output {
195        v
196    }
197}
198
199impl<I, A, T> Predicate<I, A> for NoOp<T> {
200    #[inline(always)]
201    fn is(_: &I, _: &A) -> bool {
202        true
203    }
204}
205
206impl<I, O, T: ParseImpl<I, A, Output = O>, A> ParseImpl<I, A> for Never<T> {
207    type Output = O;
208    impl_parse!(parse, _await, |__: I, _arg: A| Err(Error::Mismatch));
209}
210
211impl<I, A, T> Predicate<I, A> for Never<T> {
212    #[inline(always)]
213    fn is(_: &I, _: &A) -> bool {
214        false
215    }
216}
217
218#[allow(clippy::type_complexity)]
219pub struct And<
220    T0 = NoOp,
221    T1 = NoOp,
222    T2 = NoOp,
223    T3 = NoOp,
224    T4 = NoOp,
225    T5 = NoOp,
226    T6 = NoOp,
227    T7 = NoOp,
228    T8 = NoOp,
229    T9 = NoOp,
230    T10 = NoOp,
231    T11 = NoOp,
232    T12 = NoOp,
233    T13 = NoOp,
234    T14 = NoOp,
235    T15 = NoOp,
236    T16 = NoOp,
237    T17 = NoOp,
238    T18 = NoOp,
239    T19 = NoOp,
240    T20 = NoOp,
241    T21 = NoOp,
242    T22 = NoOp,
243    T23 = NoOp,
244    T24 = NoOp,
245    T25 = NoOp,
246    T26 = NoOp,
247    T27 = NoOp,
248    T28 = NoOp,
249    T29 = NoOp,
250    T30 = NoOp,
251    T31 = NoOp,
252>(
253    PhantomData<(
254        T0,
255        T1,
256        T2,
257        T3,
258        T4,
259        T5,
260        T6,
261        T7,
262        T8,
263        T9,
264        T10,
265        T11,
266        T12,
267        T13,
268        T14,
269        T15,
270        T16,
271        T17,
272        T18,
273        T19,
274        T20,
275        T21,
276        T22,
277        T23,
278        T24,
279        T25,
280        T26,
281        T27,
282        T28,
283        T29,
284        T30,
285        T31,
286    )>,
287);
288
289impl<
290        I,
291        T0: ParseImpl<I, A, Output = C0>,
292        T1: ParseImpl<I, A>,
293        T2: ParseImpl<I, A>,
294        T3: ParseImpl<I, A>,
295        T4: ParseImpl<I, A>,
296        T5: ParseImpl<I, A>,
297        T6: ParseImpl<I, A>,
298        T7: ParseImpl<I, A>,
299        T8: ParseImpl<I, A>,
300        T9: ParseImpl<I, A>,
301        T10: ParseImpl<I, A>,
302        T11: ParseImpl<I, A>,
303        T12: ParseImpl<I, A>,
304        T13: ParseImpl<I, A>,
305        T14: ParseImpl<I, A>,
306        T15: ParseImpl<I, A>,
307        T16: ParseImpl<I, A>,
308        T17: ParseImpl<I, A>,
309        T18: ParseImpl<I, A>,
310        T19: ParseImpl<I, A>,
311        T20: ParseImpl<I, A>,
312        T21: ParseImpl<I, A>,
313        T22: ParseImpl<I, A>,
314        T23: ParseImpl<I, A>,
315        T24: ParseImpl<I, A>,
316        T25: ParseImpl<I, A>,
317        T26: ParseImpl<I, A>,
318        T27: ParseImpl<I, A>,
319        T28: ParseImpl<I, A>,
320        T29: ParseImpl<I, A>,
321        T30: ParseImpl<I, A>,
322        T31: ParseImpl<I, A>,
323        C0: Concat<T1::Output, Output = C1>,
324        C1: Concat<T2::Output, Output = C2>,
325        C2: Concat<T3::Output, Output = C3>,
326        C3: Concat<T4::Output, Output = C4>,
327        C4: Concat<T5::Output, Output = C5>,
328        C5: Concat<T6::Output, Output = C6>,
329        C6: Concat<T7::Output, Output = C7>,
330        C7: Concat<T8::Output, Output = C8>,
331        C8: Concat<T9::Output, Output = C9>,
332        C9: Concat<T10::Output, Output = C10>,
333        C10: Concat<T11::Output, Output = C11>,
334        C11: Concat<T12::Output, Output = C12>,
335        C12: Concat<T13::Output, Output = C13>,
336        C13: Concat<T14::Output, Output = C14>,
337        C14: Concat<T15::Output, Output = C15>,
338        C15: Concat<T16::Output, Output = C16>,
339        C16: Concat<T17::Output, Output = C17>,
340        C17: Concat<T18::Output, Output = C18>,
341        C18: Concat<T19::Output, Output = C19>,
342        C19: Concat<T20::Output, Output = C20>,
343        C20: Concat<T21::Output, Output = C21>,
344        C21: Concat<T22::Output, Output = C22>,
345        C22: Concat<T23::Output, Output = C23>,
346        C23: Concat<T24::Output, Output = C24>,
347        C24: Concat<T25::Output, Output = C25>,
348        C25: Concat<T26::Output, Output = C26>,
349        C26: Concat<T27::Output, Output = C27>,
350        C27: Concat<T28::Output, Output = C28>,
351        C28: Concat<T29::Output, Output = C29>,
352        C29: Concat<T30::Output, Output = C30>,
353        C30: Concat<T31::Output, Output = C31>,
354        C31,
355        A,
356    > ParseImpl<I, A>
357    for And<
358        T0,
359        T1,
360        T2,
361        T3,
362        T4,
363        T5,
364        T6,
365        T7,
366        T8,
367        T9,
368        T10,
369        T11,
370        T12,
371        T13,
372        T14,
373        T15,
374        T16,
375        T17,
376        T18,
377        T19,
378        T20,
379        T21,
380        T22,
381        T23,
382        T24,
383        T25,
384        T26,
385        T27,
386        T28,
387        T29,
388        T30,
389        T31,
390    >
391{
392    type Output = C31;
393    impl_parse!(parse, _await, |input: I, arg: A| {
394        let r = parse!(T0, input, arg)?;
395        macro_rules! impl_concat {
396            ($r:ident, $($t:ty),*$(,)?) => {$(
397                let $r = $r.concat(parse!($t, input, arg)?);
398            )*};
399        }
400        impl_concat!(
401            r, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18,
402            T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
403        );
404        let r = r.concat(parse!(T31, input, arg)?);
405        Ok(r)
406    });
407}
408
409impl<
410        I,
411        T0: Predicate<I, A>,
412        T1: Predicate<I, A>,
413        T2: Predicate<I, A>,
414        T3: Predicate<I, A>,
415        T4: Predicate<I, A>,
416        T5: Predicate<I, A>,
417        T6: Predicate<I, A>,
418        T7: Predicate<I, A>,
419        T8: Predicate<I, A>,
420        T9: Predicate<I, A>,
421        T10: Predicate<I, A>,
422        T11: Predicate<I, A>,
423        T12: Predicate<I, A>,
424        T13: Predicate<I, A>,
425        T14: Predicate<I, A>,
426        T15: Predicate<I, A>,
427        T16: Predicate<I, A>,
428        T17: Predicate<I, A>,
429        T18: Predicate<I, A>,
430        T19: Predicate<I, A>,
431        T20: Predicate<I, A>,
432        T21: Predicate<I, A>,
433        T22: Predicate<I, A>,
434        T23: Predicate<I, A>,
435        T24: Predicate<I, A>,
436        T25: Predicate<I, A>,
437        T26: Predicate<I, A>,
438        T27: Predicate<I, A>,
439        T28: Predicate<I, A>,
440        T29: Predicate<I, A>,
441        T30: Predicate<I, A>,
442        T31: Predicate<I, A>,
443        A,
444    > Predicate<I, A>
445    for And<
446        T0,
447        T1,
448        T2,
449        T3,
450        T4,
451        T5,
452        T6,
453        T7,
454        T8,
455        T9,
456        T10,
457        T11,
458        T12,
459        T13,
460        T14,
461        T15,
462        T16,
463        T17,
464        T18,
465        T19,
466        T20,
467        T21,
468        T22,
469        T23,
470        T24,
471        T25,
472        T26,
473        T27,
474        T28,
475        T29,
476        T30,
477        T31,
478    >
479{
480    #[inline(always)]
481    fn is(v: &I, a: &A) -> bool {
482        macro_rules! impl_is {
483            ($($t:ty),*$(,)?) => {
484                $(<$t>::is(v, a))&&*
485            };
486        }
487        impl_is!(
488            T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18,
489            T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31,
490        )
491    }
492}
493
494#[allow(clippy::type_complexity)]
495pub struct Or<
496    T0 = Never<NoOp>,
497    T1 = Never<T0>,
498    T2 = Never<T0>,
499    T3 = Never<T0>,
500    T4 = Never<T0>,
501    T5 = Never<T0>,
502    T6 = Never<T0>,
503    T7 = Never<T0>,
504    T8 = Never<T0>,
505    T9 = Never<T0>,
506    T10 = Never<T0>,
507    T11 = Never<T0>,
508    T12 = Never<T0>,
509    T13 = Never<T0>,
510    T14 = Never<T0>,
511    T15 = Never<T0>,
512    T16 = Never<T0>,
513    T17 = Never<T0>,
514    T18 = Never<T0>,
515    T19 = Never<T0>,
516    T20 = Never<T0>,
517    T21 = Never<T0>,
518    T22 = Never<T0>,
519    T23 = Never<T0>,
520    T24 = Never<T0>,
521    T25 = Never<T0>,
522    T26 = Never<T0>,
523    T27 = Never<T0>,
524    T28 = Never<T0>,
525    T29 = Never<T0>,
526    T30 = Never<T0>,
527    T31 = Never<T0>,
528>(
529    PhantomData<(
530        T0,
531        T1,
532        T2,
533        T3,
534        T4,
535        T5,
536        T6,
537        T7,
538        T8,
539        T9,
540        T10,
541        T11,
542        T12,
543        T13,
544        T14,
545        T15,
546        T16,
547        T17,
548        T18,
549        T19,
550        T20,
551        T21,
552        T22,
553        T23,
554        T24,
555        T25,
556        T26,
557        T27,
558        T28,
559        T29,
560        T30,
561        T31,
562    )>,
563);
564
565impl<
566        T0: ParseImpl<I, A, Output = O>,
567        T1: ParseImpl<I, A, Output = O>,
568        T2: ParseImpl<I, A, Output = O>,
569        T3: ParseImpl<I, A, Output = O>,
570        T4: ParseImpl<I, A, Output = O>,
571        T5: ParseImpl<I, A, Output = O>,
572        T6: ParseImpl<I, A, Output = O>,
573        T7: ParseImpl<I, A, Output = O>,
574        T8: ParseImpl<I, A, Output = O>,
575        T9: ParseImpl<I, A, Output = O>,
576        T10: ParseImpl<I, A, Output = O>,
577        T11: ParseImpl<I, A, Output = O>,
578        T12: ParseImpl<I, A, Output = O>,
579        T13: ParseImpl<I, A, Output = O>,
580        T14: ParseImpl<I, A, Output = O>,
581        T15: ParseImpl<I, A, Output = O>,
582        T16: ParseImpl<I, A, Output = O>,
583        T17: ParseImpl<I, A, Output = O>,
584        T18: ParseImpl<I, A, Output = O>,
585        T19: ParseImpl<I, A, Output = O>,
586        T20: ParseImpl<I, A, Output = O>,
587        T21: ParseImpl<I, A, Output = O>,
588        T22: ParseImpl<I, A, Output = O>,
589        T23: ParseImpl<I, A, Output = O>,
590        T24: ParseImpl<I, A, Output = O>,
591        T25: ParseImpl<I, A, Output = O>,
592        T26: ParseImpl<I, A, Output = O>,
593        T27: ParseImpl<I, A, Output = O>,
594        T28: ParseImpl<I, A, Output = O>,
595        T29: ParseImpl<I, A, Output = O>,
596        T30: ParseImpl<I, A, Output = O>,
597        T31: ParseImpl<I, A, Output = O>,
598        I,
599        O,
600        A,
601    > ParseImpl<I, A>
602    for Or<
603        T0,
604        T1,
605        T2,
606        T3,
607        T4,
608        T5,
609        T6,
610        T7,
611        T8,
612        T9,
613        T10,
614        T11,
615        T12,
616        T13,
617        T14,
618        T15,
619        T16,
620        T17,
621        T18,
622        T19,
623        T20,
624        T21,
625        T22,
626        T23,
627        T24,
628        T25,
629        T26,
630        T27,
631        T28,
632        T29,
633        T30,
634        T31,
635    >
636{
637    type Output = O;
638    impl_parse!(parse, _await, |input: I, arg: A| {
639        macro_rules! impl_or {
640            ($i:expr, $($t:ty),*$(,)?) => {$(
641                let mut fork = $i.fork();
642                match parse!($t, &mut fork, arg) {
643                    Ok(item) => {
644                        fork.join();
645                        return Ok(item);
646                    }
647                    Err(e @ Error::Hard(_)) => {
648                        fork.join();
649                        return Err(e);
650                    }
651                    _ => drop(fork),
652                }
653            )*};
654        }
655        impl_or!(
656            input, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17,
657            T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
658        );
659
660        let mut fork = input.fork();
661        match parse!(T31, &mut fork, arg) {
662            Ok(item) => {
663                fork.join();
664                return Ok(item);
665            }
666            Err(e @ Error::Hard(_)) => {
667                fork.join();
668                return Err(e);
669            }
670            _ => drop(fork),
671        }
672
673        Err(Error::Mismatch)
674    });
675}
676
677impl<
678        I,
679        T0: Predicate<I, A>,
680        T1: Predicate<I, A>,
681        T2: Predicate<I, A>,
682        T3: Predicate<I, A>,
683        T4: Predicate<I, A>,
684        T5: Predicate<I, A>,
685        T6: Predicate<I, A>,
686        T7: Predicate<I, A>,
687        T8: Predicate<I, A>,
688        T9: Predicate<I, A>,
689        T10: Predicate<I, A>,
690        T11: Predicate<I, A>,
691        T12: Predicate<I, A>,
692        T13: Predicate<I, A>,
693        T14: Predicate<I, A>,
694        T15: Predicate<I, A>,
695        T16: Predicate<I, A>,
696        T17: Predicate<I, A>,
697        T18: Predicate<I, A>,
698        T19: Predicate<I, A>,
699        T20: Predicate<I, A>,
700        T21: Predicate<I, A>,
701        T22: Predicate<I, A>,
702        T23: Predicate<I, A>,
703        T24: Predicate<I, A>,
704        T25: Predicate<I, A>,
705        T26: Predicate<I, A>,
706        T27: Predicate<I, A>,
707        T28: Predicate<I, A>,
708        T29: Predicate<I, A>,
709        T30: Predicate<I, A>,
710        T31: Predicate<I, A>,
711        A,
712    > Predicate<I, A>
713    for Or<
714        T0,
715        T1,
716        T2,
717        T3,
718        T4,
719        T5,
720        T6,
721        T7,
722        T8,
723        T9,
724        T10,
725        T11,
726        T12,
727        T13,
728        T14,
729        T15,
730        T16,
731        T17,
732        T18,
733        T19,
734        T20,
735        T21,
736        T22,
737        T23,
738        T24,
739        T25,
740        T26,
741        T27,
742        T28,
743        T29,
744        T30,
745        T31,
746    >
747{
748    #[inline(always)]
749    fn is(v: &I, a: &A) -> bool {
750        macro_rules! impl_is {
751            ($($t:ty),*$(,)?) => {
752                $(<$t>::is(v, a))||*
753            };
754        }
755        impl_is!(
756            T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18,
757            T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31,
758        )
759    }
760}
761
762pub struct Repeat<T, const MIN: usize = 0, const MAX: usize = { usize::MAX }>(PhantomData<T>);
763
764impl<I, T: ParseImpl<I, A, Output = (O,)>, O, A, const MIN: usize, const MAX: usize> ParseImpl<I, A>
765    for Repeat<T, MIN, MAX>
766{
767    type Output = (Vec<O>,);
768    impl_parse!(parse, _await, |input: I, arg: A| {
769        let mut result = Vec::new();
770        let mut le = None;
771        for _ in 0..MAX {
772            match parse!(T, input, arg) {
773                Ok((item,)) => result.push(item),
774                Err(e @ Error::Hard(_)) => {
775                    return Err(e);
776                }
777                Err(e) => {
778                    le = Some(e);
779                    break;
780                }
781            }
782        }
783        if result.len() < MIN {
784            return Err(le.unwrap_or(Error::Mismatch));
785        }
786        Ok((result,))
787    });
788}
789
790pub struct Optional<T>(PhantomData<T>);
791
792impl<I, T: ParseImpl<I, A, Output = (O,)>, O, A> ParseImpl<I, A> for Optional<T> {
793    type Output = (Option<O>,);
794    impl_parse!(parse, _await, |input: I, arg: A| {
795        match parse!(T, input, arg) {
796            Ok((item,)) => Ok((Some(item),)),
797            Err(e @ Error::Hard(_)) => Err(e),
798            Err(_) => Ok((None,)),
799        }
800    });
801}
802
803pub struct Punctuated<T, P, const MIN: usize = 0, const MAX: usize = { usize::MAX }>(
804    PhantomData<(T, P)>,
805);
806
807impl<
808        I: core::fmt::Debug,
809        T: ParseImpl<I, A, Output = (O,)>,
810        O,
811        P: ParseImpl<I, A, Output = (PO,)>,
812        PO,
813        A,
814        const MIN: usize,
815        const MAX: usize,
816    > ParseImpl<I, A> for Punctuated<T, P, MIN, MAX>
817{
818    type Output = (Vec<O>, Vec<PO>);
819    impl_parse!(parse, _await, |input: I, arg: A| {
820        let mut result = Vec::new();
821        let mut puncts = Vec::new();
822        let mut le = None;
823
824        'matching: {
825            match parse!(T, input, arg) {
826                Ok((item,)) => result.push(item),
827                Err(e @ Error::Hard(_)) => {
828                    return Err(e);
829                }
830                Err(e) => {
831                    le = Some(e);
832                    break 'matching;
833                }
834            }
835
836            for _ in 1..MAX {
837                let mut input = input.fork();
838                match parse!(P, &mut input, arg) {
839                    Ok((item,)) => puncts.push(item),
840                    Err(e @ Error::Hard(_)) => {
841                        return Err(e);
842                    }
843                    Err(e) => {
844                        le = Some(e);
845                        break;
846                    }
847                }
848
849                match parse!(T, &mut input, arg) {
850                    Ok((item,)) => {
851                        result.push(item);
852                        input.join();
853                    }
854                    Err(e @ Error::Hard(_)) => {
855                        return Err(e);
856                    }
857                    Err(e) => {
858                        puncts.pop();
859                        le = Some(e);
860                        break;
861                    }
862                }
863            }
864        }
865        if result.len() < MIN {
866            return Err(le.unwrap_or(Error::Mismatch));
867        }
868        Ok((result, puncts))
869    });
870}
871
872pub struct Map<P, M = NoOp>(PhantomData<(P, M)>);
873
874pub struct TryMap<P, M>(PhantomData<(P, M)>);
875
876pub struct IsMap<P, M>(PhantomData<(P, M)>);
877
878impl<I, P: ParseImpl<I, A, Output = T>, M: Mapper<T, A, Output = U>, T, U, A> ParseImpl<I, A>
879    for Map<P, M>
880{
881    type Output = (U,);
882    impl_parse!(parse, _await, |input: I, arg: A| Ok((M::map(
883        parse!(P, input, arg)?,
884        arg
885    ),)));
886}
887
888impl<I, P: ParseImpl<I, A, Output = T>, M: Mapper<T, A, Output = Result<U>>, T, U, A>
889    ParseImpl<I, A> for TryMap<P, M>
890{
891    type Output = (U,);
892    impl_parse!(parse, _await, |input: I, arg: A| Ok((M::map(
893        parse!(P, input, arg)?,
894        arg
895    )?,)));
896}
897
898impl<I, P: ParseImpl<I, A, Output = T>, M: Mapper<T, A, Output = Option<U>>, T, U, A>
899    ParseImpl<I, A> for IsMap<P, M>
900{
901    type Output = (U,);
902    impl_parse!(parse, _await, |input: I, arg: A| Ok((M::map(
903        parse!(P, input, arg)?,
904        arg
905    )
906    .ok_or(Error::Mismatch)?,)));
907}
908
909pub struct Expected<T, N>(PhantomData<(T, N)>);
910
911impl<I, T: ParseImpl<I, A>, N: Const<Type = &'static str>, A> ParseImpl<I, A> for Expected<T, N> {
912    type Output = T::Output;
913    impl_parse!(parse, _await, |input: I, arg: A| parse!(T, input, arg)
914        .map_err(|e| {
915            match e {
916                Error::Mismatch => HardError::Incomplete {
917                    position: input.position(),
918                    name: N::VALUE,
919                }
920                .into(),
921                Error::NamedMismatch(component_name) => HardError::NamedIncomplete {
922                    position: input.position(),
923                    name: N::VALUE,
924                    component_name,
925                }
926                .into(),
927                _ => e,
928            }
929        }));
930}
931
932pub struct Name<T, N>(PhantomData<(T, N)>);
933
934impl<I, T: ParseImpl<I, A>, N: Const<Type = &'static str>, A> ParseImpl<I, A> for Name<T, N> {
935    type Output = T::Output;
936    impl_parse!(parse, _await, |input: I, arg: A| parse!(T, input, arg)
937        .map_err(|e| {
938            if let Error::Mismatch = e {
939                Error::NamedMismatch(N::VALUE)
940            } else {
941                e
942            }
943        }));
944}
945
946pub struct Peek<T>(PhantomData<T>);
947
948impl<T: ParseImpl<I, A>, I, A> ParseImpl<I, A> for Peek<T> {
949    type Output = T::Output;
950    impl_parse!(parse, _await, |input: I, arg: A| parse!(
951        T,
952        &mut input.fork(),
953        arg
954    ));
955}
956
957pub struct AndWithArg<T0 = NoOp, T1 = NoOp>(PhantomData<(T0, T1)>);
958
959impl<I, T0: ParseImpl<I, A0, Output = (A1,)>, T1: ParseImpl<I, A1>, A0, A1: Clone> ParseImpl<I, A0>
960    for AndWithArg<T0, T1>
961where
962    (A1,): Concat<T1::Output>,
963{
964    type Output = <(A1,) as Concat<T1::Output>>::Output;
965
966    impl_parse!(parse, _await, |input: I, arg: A0| {
967        let r = parse!(T0, input, arg)?;
968        Ok(r.clone().concat(parse!(T1, input, &r.0)?))
969    });
970}
971
972pub struct MapRange<T, M = ConcatArg>(PhantomData<(T, M)>);
973
974impl<I, A, T: ParseImpl<I, A>, M: Mapper<T::Output, Range<usize>>> ParseImpl<I, A>
975    for MapRange<T, M>
976{
977    type Output = (M::Output,);
978    impl_parse!(parse, _await, |input: I, arg: A| {
979        let start = input.position();
980        let result = parse!(T, input, arg)?;
981        let end = input.position();
982        Ok((M::map(result, &(start..end)),))
983    });
984}
985
986pub struct ConcatArg;
987
988impl<T: Concat<(A,)>, A: Clone> Mapper<T, A> for ConcatArg {
989    type Output = T::Output;
990    #[inline(always)]
991    fn map(v: T, a: &A) -> Self::Output {
992        v.concat((a.clone(),))
993    }
994}
995
996pub struct Start;
997
998impl<I, A> ParseImpl<I, A> for Start {
999    type Output = ();
1000    impl_parse!(parse, _await, |input: I, _arg: A| {
1001        if input.position() == 0 {
1002            Ok(())
1003        } else {
1004            Err(Error::Mismatch)
1005        }
1006    });
1007}
1008
1009pub struct End;
1010
1011impl<I, A> ParseImpl<I, A> for End {
1012    type Output = ();
1013    impl_parse!(parse, _await, |input: I, _arg: A| {
1014        if _await!(input.read(1))?.is_empty() {
1015            Ok(())
1016        } else {
1017            Err(Error::Mismatch)
1018        }
1019    });
1020}
xparse/ops.rs

xparse/
ops.rs
