winnow/combinator/
impls.rs

1//! Opaque implementations of [`Parser`]
2
3use crate::combinator::trace;
4use crate::combinator::trace_result;
5use crate::combinator::DisplayDebug;
6#[cfg(feature = "unstable-recover")]
7#[cfg(feature = "std")]
8use crate::error::FromRecoverableError;
9use crate::error::ParseError;
10use crate::error::{AddContext, FromExternalError, ParserError};
11#[cfg(feature = "unstable-recover")]
12#[cfg(feature = "std")]
13use crate::stream::Recover;
14use crate::stream::StreamIsPartial;
15use crate::stream::{Location, Stream};
16use crate::{Parser, Result};
17use core::borrow::Borrow;
18use core::ops::Range;
19
20/// Iterator implementation for [`Parser::parse_iter`]
21pub struct ParseIter<'p, P, I, O, E>
22where
23    I: Stream,
24{
25    pub(crate) parser: &'p mut P,
26    pub(crate) input: Option<I>,
27    pub(crate) start: Option<I::Checkpoint>,
28    pub(crate) marker: core::marker::PhantomData<(O, E)>,
29}
30
31impl<'p, I, O, E, P> Iterator for ParseIter<'p, P, I, O, E>
32where
33    P: Parser<I, O, E>,
34    I: Stream,
35    // Force users to deal with `Incomplete` when `StreamIsPartial<true>`
36    I: StreamIsPartial,
37    E: ParserError<I>,
38    <E as ParserError<I>>::Inner: ParserError<I>,
39{
40    type Item = Result<O, ParseError<I, <E as ParserError<I>>::Inner>>;
41
42    fn next(&mut self) -> Option<Self::Item> {
43        let input = self.input.as_mut()?;
44        let len = input.eof_offset();
45        if len == 0 {
46            self.input = None;
47            return None;
48        }
49
50        let mut output = self.parser.parse_next(input);
51        // infinite loop check: the parser must always consume
52        if output.is_ok() && input.eof_offset() == len {
53            let err = <E as ParserError<I>>::assert(
54                input,
55                "`Parser::parse_iter` parsers must always consume",
56            );
57            output = Err(err);
58        }
59
60        match output {
61            Ok(output) => Some(Ok(output)),
62            Err(err) => {
63                let err = err.into_inner().unwrap_or_else(|_err| {
64                    panic!("complete parsers should not report `ErrMode::Incomplete(_)`")
65                });
66                let input = self.input.take()?;
67                let start = self.start.take()?;
68                Some(Err(ParseError::new(input, start, err)))
69            }
70        }
71    }
72}
73
74/// [`Parser`] implementation for [`Parser::by_ref`]
75pub struct ByRef<'p, P, I, O, E> {
76    pub(crate) p: &'p mut P,
77    pub(crate) marker: core::marker::PhantomData<(I, O, E)>,
78}
79
80impl<I, O, E, P> Parser<I, O, E> for ByRef<'_, P, I, O, E>
81where
82    P: Parser<I, O, E>,
83{
84    #[inline(always)]
85    fn parse_next(&mut self, i: &mut I) -> Result<O, E> {
86        self.p.parse_next(i)
87    }
88}
89
90/// [`Parser`] implementation for [`Parser::map`]
91pub struct Map<F, G, I, O, O2, E>
92where
93    F: Parser<I, O, E>,
94    G: FnMut(O) -> O2,
95{
96    pub(crate) parser: F,
97    pub(crate) map: G,
98    pub(crate) marker: core::marker::PhantomData<(I, O, E, O2)>,
99}
100
101impl<F, G, I, O, O2, E> Parser<I, O2, E> for Map<F, G, I, O, O2, E>
102where
103    F: Parser<I, O, E>,
104    G: FnMut(O) -> O2,
105{
106    #[inline]
107    fn parse_next(&mut self, i: &mut I) -> Result<O2, E> {
108        match self.parser.parse_next(i) {
109            Err(e) => Err(e),
110            Ok(o) => Ok((self.map)(o)),
111        }
112    }
113}
114
115/// [`Parser`] implementation for [`Parser::try_map`]
116pub struct TryMap<F, G, I, O, O2, E, E2>
117where
118    F: Parser<I, O, E>,
119    G: FnMut(O) -> Result<O2, E2>,
120    I: Stream,
121    E: FromExternalError<I, E2>,
122    E: ParserError<I>,
123{
124    pub(crate) parser: F,
125    pub(crate) map: G,
126    pub(crate) marker: core::marker::PhantomData<(I, O, O2, E, E2)>,
127}
128
129impl<F, G, I, O, O2, E, E2> Parser<I, O2, E> for TryMap<F, G, I, O, O2, E, E2>
130where
131    F: Parser<I, O, E>,
132    G: FnMut(O) -> Result<O2, E2>,
133    I: Stream,
134    E: FromExternalError<I, E2>,
135    E: ParserError<I>,
136{
137    #[inline]
138    fn parse_next(&mut self, input: &mut I) -> Result<O2, E> {
139        let start = input.checkpoint();
140        let o = self.parser.parse_next(input)?;
141        let res = (self.map)(o).map_err(|err| {
142            input.reset(&start);
143            E::from_external_error(input, err)
144        });
145        trace_result("verify", &res);
146        res
147    }
148}
149
150/// [`Parser`] implementation for [`Parser::verify_map`]
151pub struct VerifyMap<F, G, I, O, O2, E>
152where
153    F: Parser<I, O, E>,
154    G: FnMut(O) -> Option<O2>,
155    I: Stream,
156    E: ParserError<I>,
157{
158    pub(crate) parser: F,
159    pub(crate) map: G,
160    pub(crate) marker: core::marker::PhantomData<(I, O, E, O2)>,
161}
162
163impl<F, G, I, O, O2, E> Parser<I, O2, E> for VerifyMap<F, G, I, O, O2, E>
164where
165    F: Parser<I, O, E>,
166    G: FnMut(O) -> Option<O2>,
167    I: Stream,
168    E: ParserError<I>,
169{
170    #[inline]
171    fn parse_next(&mut self, input: &mut I) -> Result<O2, E> {
172        let start = input.checkpoint();
173        let o = self.parser.parse_next(input)?;
174        let res = (self.map)(o).ok_or_else(|| {
175            input.reset(&start);
176            ParserError::from_input(input)
177        });
178        trace_result("verify", &res);
179        res
180    }
181}
182
183/// [`Parser`] implementation for [`Parser::and_then`]
184pub struct AndThen<F, G, I, O, O2, E>
185where
186    F: Parser<I, O, E>,
187    G: Parser<O, O2, E>,
188    O: StreamIsPartial,
189    I: Stream,
190{
191    pub(crate) outer: F,
192    pub(crate) inner: G,
193    pub(crate) marker: core::marker::PhantomData<(I, O, O2, E)>,
194}
195
196impl<F, G, I, O, O2, E> Parser<I, O2, E> for AndThen<F, G, I, O, O2, E>
197where
198    F: Parser<I, O, E>,
199    G: Parser<O, O2, E>,
200    O: StreamIsPartial,
201    I: Stream,
202{
203    #[inline(always)]
204    fn parse_next(&mut self, i: &mut I) -> Result<O2, E> {
205        let start = i.checkpoint();
206        let mut o = self.outer.parse_next(i)?;
207        let _ = o.complete();
208        let o2 = self.inner.parse_next(&mut o).map_err(|err| {
209            i.reset(&start);
210            err
211        })?;
212        Ok(o2)
213    }
214}
215
216/// [`Parser`] implementation for [`Parser::parse_to`]
217pub struct ParseTo<P, I, O, O2, E>
218where
219    P: Parser<I, O, E>,
220    I: Stream,
221    O: crate::stream::ParseSlice<O2>,
222    E: ParserError<I>,
223{
224    pub(crate) p: P,
225    pub(crate) marker: core::marker::PhantomData<(I, O, O2, E)>,
226}
227
228impl<P, I, O, O2, E> Parser<I, O2, E> for ParseTo<P, I, O, O2, E>
229where
230    P: Parser<I, O, E>,
231    I: Stream,
232    O: crate::stream::ParseSlice<O2>,
233    E: ParserError<I>,
234{
235    #[inline]
236    fn parse_next(&mut self, i: &mut I) -> Result<O2, E> {
237        let start = i.checkpoint();
238        let o = self.p.parse_next(i)?;
239        let res = o.parse_slice().ok_or_else(|| {
240            i.reset(&start);
241            ParserError::from_input(i)
242        });
243        trace_result("verify", &res);
244        res
245    }
246}
247
248/// [`Parser`] implementation for [`Parser::flat_map`]
249pub struct FlatMap<F, G, H, I, O, O2, E>
250where
251    F: Parser<I, O, E>,
252    G: FnMut(O) -> H,
253    H: Parser<I, O2, E>,
254{
255    pub(crate) f: F,
256    pub(crate) g: G,
257    pub(crate) marker: core::marker::PhantomData<(H, I, O, O2, E)>,
258}
259
260impl<F, G, H, I, O, O2, E> Parser<I, O2, E> for FlatMap<F, G, H, I, O, O2, E>
261where
262    F: Parser<I, O, E>,
263    G: FnMut(O) -> H,
264    H: Parser<I, O2, E>,
265{
266    #[inline(always)]
267    fn parse_next(&mut self, i: &mut I) -> Result<O2, E> {
268        let o = self.f.parse_next(i)?;
269        (self.g)(o).parse_next(i)
270    }
271}
272
273/// [`Parser`] implementation for [`Parser::complete_err`]
274pub struct CompleteErr<P, I, O, E> {
275    pub(crate) p: P,
276    pub(crate) marker: core::marker::PhantomData<(I, O, E)>,
277}
278
279impl<P, I, O, E> Parser<I, O, E> for CompleteErr<P, I, O, E>
280where
281    P: Parser<I, O, E>,
282    I: Stream,
283    E: ParserError<I>,
284{
285    #[inline]
286    fn parse_next(&mut self, input: &mut I) -> Result<O, E> {
287        trace("complete_err", |input: &mut I| {
288            match (self.p).parse_next(input) {
289                Err(err) => match err.needed() {
290                    Some(_) => Err(ParserError::from_input(input)),
291                    None => Err(err),
292                },
293                rest => rest,
294            }
295        })
296        .parse_next(input)
297    }
298}
299
300/// [`Parser`] implementation for [`Parser::verify`]
301pub struct Verify<F, G, I, O, O2, E>
302where
303    F: Parser<I, O, E>,
304    G: FnMut(&O2) -> bool,
305    I: Stream,
306    O: Borrow<O2>,
307    O2: ?Sized,
308    E: ParserError<I>,
309{
310    pub(crate) parser: F,
311    pub(crate) filter: G,
312    pub(crate) marker: core::marker::PhantomData<(I, O, E, O2)>,
313}
314
315impl<F, G, I, O, O2, E> Parser<I, O, E> for Verify<F, G, I, O, O2, E>
316where
317    F: Parser<I, O, E>,
318    G: FnMut(&O2) -> bool,
319    I: Stream,
320    O: Borrow<O2>,
321    O2: ?Sized,
322    E: ParserError<I>,
323{
324    #[inline]
325    fn parse_next(&mut self, input: &mut I) -> Result<O, E> {
326        let start = input.checkpoint();
327        let o = self.parser.parse_next(input)?;
328        let res = (self.filter)(o.borrow()).then_some(o).ok_or_else(|| {
329            input.reset(&start);
330            ParserError::from_input(input)
331        });
332        trace_result("verify", &res);
333        res
334    }
335}
336
337/// [`Parser`] implementation for [`Parser::value`]
338pub struct Value<F, I, O, O2, E>
339where
340    F: Parser<I, O, E>,
341    O2: Clone,
342{
343    pub(crate) parser: F,
344    pub(crate) val: O2,
345    pub(crate) marker: core::marker::PhantomData<(I, O, E)>,
346}
347
348impl<F, I, O, O2, E> Parser<I, O2, E> for Value<F, I, O, O2, E>
349where
350    F: Parser<I, O, E>,
351    O2: Clone,
352{
353    #[inline]
354    fn parse_next(&mut self, input: &mut I) -> Result<O2, E> {
355        (self.parser).parse_next(input).map(|_| self.val.clone())
356    }
357}
358
359/// [`Parser`] implementation for [`Parser::default_value`]
360pub struct DefaultValue<F, I, O, O2, E>
361where
362    F: Parser<I, O, E>,
363    O2: core::default::Default,
364{
365    pub(crate) parser: F,
366    pub(crate) marker: core::marker::PhantomData<(O2, I, O, E)>,
367}
368
369impl<F, I, O, O2, E> Parser<I, O2, E> for DefaultValue<F, I, O, O2, E>
370where
371    F: Parser<I, O, E>,
372    O2: core::default::Default,
373{
374    #[inline]
375    fn parse_next(&mut self, input: &mut I) -> Result<O2, E> {
376        (self.parser).parse_next(input).map(|_| O2::default())
377    }
378}
379
380/// [`Parser`] implementation for [`Parser::void`]
381pub struct Void<F, I, O, E>
382where
383    F: Parser<I, O, E>,
384{
385    pub(crate) parser: F,
386    pub(crate) marker: core::marker::PhantomData<(I, O, E)>,
387}
388
389impl<F, I, O, E> Parser<I, (), E> for Void<F, I, O, E>
390where
391    F: Parser<I, O, E>,
392{
393    #[inline(always)]
394    fn parse_next(&mut self, input: &mut I) -> Result<(), E> {
395        (self.parser).parse_next(input).map(|_| ())
396    }
397}
398
399/// [`Parser`] implementation for [`Parser::take`]
400pub struct Take<F, I, O, E>
401where
402    F: Parser<I, O, E>,
403    I: Stream,
404{
405    pub(crate) parser: F,
406    pub(crate) marker: core::marker::PhantomData<(I, O, E)>,
407}
408
409impl<I, O, E, F> Parser<I, <I as Stream>::Slice, E> for Take<F, I, O, E>
410where
411    F: Parser<I, O, E>,
412    I: Stream,
413{
414    #[inline]
415    fn parse_next(&mut self, input: &mut I) -> Result<<I as Stream>::Slice, E> {
416        let checkpoint = input.checkpoint();
417        match (self.parser).parse_next(input) {
418            Ok(_) => {
419                let offset = input.offset_from(&checkpoint);
420                input.reset(&checkpoint);
421                let taken = input.next_slice(offset);
422                Ok(taken)
423            }
424            Err(e) => Err(e),
425        }
426    }
427}
428
429/// [`Parser`] implementation for [`Parser::with_taken`]
430pub struct WithTaken<F, I, O, E>
431where
432    F: Parser<I, O, E>,
433    I: Stream,
434{
435    pub(crate) parser: F,
436    pub(crate) marker: core::marker::PhantomData<(I, O, E)>,
437}
438
439impl<F, I, O, E> Parser<I, (O, <I as Stream>::Slice), E> for WithTaken<F, I, O, E>
440where
441    F: Parser<I, O, E>,
442    I: Stream,
443{
444    #[inline]
445    fn parse_next(&mut self, input: &mut I) -> Result<(O, <I as Stream>::Slice), E> {
446        let checkpoint = input.checkpoint();
447        match (self.parser).parse_next(input) {
448            Ok(result) => {
449                let offset = input.offset_from(&checkpoint);
450                input.reset(&checkpoint);
451                let taken = input.next_slice(offset);
452                Ok((result, taken))
453            }
454            Err(e) => Err(e),
455        }
456    }
457}
458
459/// [`Parser`] implementation for [`Parser::span`]
460pub struct Span<F, I, O, E>
461where
462    F: Parser<I, O, E>,
463    I: Stream + Location,
464{
465    pub(crate) parser: F,
466    pub(crate) marker: core::marker::PhantomData<(I, O, E)>,
467}
468
469impl<I, O, E, F> Parser<I, Range<usize>, E> for Span<F, I, O, E>
470where
471    F: Parser<I, O, E>,
472    I: Stream + Location,
473{
474    #[inline]
475    fn parse_next(&mut self, input: &mut I) -> Result<Range<usize>, E> {
476        let start = input.current_token_start();
477        self.parser.parse_next(input).map(move |_| {
478            let end = input.previous_token_end();
479            start..end
480        })
481    }
482}
483
484/// [`Parser`] implementation for [`Parser::with_span`]
485pub struct WithSpan<F, I, O, E>
486where
487    F: Parser<I, O, E>,
488    I: Stream + Location,
489{
490    pub(crate) parser: F,
491    pub(crate) marker: core::marker::PhantomData<(I, O, E)>,
492}
493
494impl<F, I, O, E> Parser<I, (O, Range<usize>), E> for WithSpan<F, I, O, E>
495where
496    F: Parser<I, O, E>,
497    I: Stream + Location,
498{
499    #[inline]
500    fn parse_next(&mut self, input: &mut I) -> Result<(O, Range<usize>), E> {
501        let start = input.current_token_start();
502        self.parser.parse_next(input).map(move |output| {
503            let end = input.previous_token_end();
504            (output, (start..end))
505        })
506    }
507}
508
509/// [`Parser`] implementation for [`Parser::output_into`]
510pub struct OutputInto<F, I, O, O2, E>
511where
512    F: Parser<I, O, E>,
513    O: Into<O2>,
514{
515    pub(crate) parser: F,
516    pub(crate) marker: core::marker::PhantomData<(I, O, O2, E)>,
517}
518
519impl<F, I, O, O2, E> Parser<I, O2, E> for OutputInto<F, I, O, O2, E>
520where
521    F: Parser<I, O, E>,
522    O: Into<O2>,
523{
524    #[inline]
525    fn parse_next(&mut self, i: &mut I) -> Result<O2, E> {
526        self.parser.parse_next(i).map(|o| o.into())
527    }
528}
529
530/// [`Parser`] implementation for [`Parser::err_into`]
531pub struct ErrInto<F, I, O, E, E2>
532where
533    F: Parser<I, O, E>,
534    E: Into<E2>,
535{
536    pub(crate) parser: F,
537    pub(crate) marker: core::marker::PhantomData<(I, O, E, E2)>,
538}
539
540impl<F, I, O, E, E2> Parser<I, O, E2> for ErrInto<F, I, O, E, E2>
541where
542    F: Parser<I, O, E>,
543    E: Into<E2>,
544{
545    #[inline]
546    fn parse_next(&mut self, i: &mut I) -> Result<O, E2> {
547        self.parser.parse_next(i).map_err(|err| err.into())
548    }
549}
550
551/// [`Parser`] implementation for [`Parser::context`]
552pub struct Context<F, I, O, E, C>
553where
554    F: Parser<I, O, E>,
555    I: Stream,
556    E: AddContext<I, C>,
557    E: ParserError<I>,
558    C: Clone + core::fmt::Debug,
559{
560    pub(crate) parser: F,
561    pub(crate) context: C,
562    pub(crate) marker: core::marker::PhantomData<(I, O, E)>,
563}
564
565impl<F, I, O, E, C> Parser<I, O, E> for Context<F, I, O, E, C>
566where
567    F: Parser<I, O, E>,
568    I: Stream,
569    E: AddContext<I, C>,
570    E: ParserError<I>,
571    C: Clone + core::fmt::Debug,
572{
573    #[inline]
574    fn parse_next(&mut self, i: &mut I) -> Result<O, E> {
575        let context = self.context.clone();
576        trace(DisplayDebug(self.context.clone()), move |i: &mut I| {
577            let start = i.checkpoint();
578            (self.parser)
579                .parse_next(i)
580                .map_err(|err| err.add_context(i, &start, context.clone()))
581        })
582        .parse_next(i)
583    }
584}
585
586/// [`Parser`] implementation for [`Parser::context`]
587pub struct ContextWith<P, I, O, E, F, C, FI>
588where
589    P: Parser<I, O, E>,
590    I: Stream,
591    E: AddContext<I, C>,
592    E: ParserError<I>,
593    F: Fn() -> FI + Clone,
594    C: core::fmt::Debug,
595    FI: Iterator<Item = C>,
596{
597    pub(crate) parser: P,
598    pub(crate) context: F,
599    pub(crate) marker: core::marker::PhantomData<(I, O, E, C, FI)>,
600}
601
602impl<P, I, O, E, F, C, FI> Parser<I, O, E> for ContextWith<P, I, O, E, F, C, FI>
603where
604    P: Parser<I, O, E>,
605    I: Stream,
606    E: AddContext<I, C>,
607    E: ParserError<I>,
608    F: Fn() -> FI + Clone,
609    C: core::fmt::Debug,
610    FI: Iterator<Item = C>,
611{
612    #[inline]
613    fn parse_next(&mut self, i: &mut I) -> Result<O, E> {
614        let context = self.context.clone();
615        let start = i.checkpoint();
616        (self.parser).parse_next(i).map_err(|mut err| {
617            for context in context() {
618                err = err.add_context(i, &start, context);
619            }
620            err
621        })
622    }
623}
624
625/// [`Parser`] implementation for [`Parser::map_err`]
626pub struct MapErr<F, G, I, O, E, E2>
627where
628    F: Parser<I, O, E>,
629    G: FnMut(E) -> E2,
630{
631    pub(crate) parser: F,
632    pub(crate) map: G,
633    pub(crate) marker: core::marker::PhantomData<(I, O, E, E2)>,
634}
635
636impl<F, G, I, O, E, E2> Parser<I, O, E2> for MapErr<F, G, I, O, E, E2>
637where
638    F: Parser<I, O, E>,
639    G: FnMut(E) -> E2,
640{
641    #[inline]
642    fn parse_next(&mut self, i: &mut I) -> Result<O, E2> {
643        match self.parser.parse_next(i) {
644            Err(e) => Err((self.map)(e)),
645            Ok(o) => Ok(o),
646        }
647    }
648}
649
650/// [`Parser`] implementation for [`Parser::retry_after`]
651#[cfg(feature = "unstable-recover")]
652#[cfg(feature = "std")]
653pub struct RetryAfter<P, R, I, O, E>
654where
655    P: Parser<I, O, E>,
656    R: Parser<I, (), E>,
657    I: Stream,
658    I: Recover<E>,
659    E: ParserError<I> + FromRecoverableError<I, E>,
660{
661    pub(crate) parser: P,
662    pub(crate) recover: R,
663    pub(crate) marker: core::marker::PhantomData<(I, O, E)>,
664}
665
666#[cfg(feature = "unstable-recover")]
667#[cfg(feature = "std")]
668impl<P, R, I, O, E> Parser<I, O, E> for RetryAfter<P, R, I, O, E>
669where
670    P: Parser<I, O, E>,
671    R: Parser<I, (), E>,
672    I: Stream,
673    I: Recover<E>,
674    E: ParserError<I> + FromRecoverableError<I, E>,
675{
676    #[inline(always)]
677    fn parse_next(&mut self, i: &mut I) -> Result<O, E> {
678        if I::is_recovery_supported() {
679            retry_after_inner(&mut self.parser, &mut self.recover, i)
680        } else {
681            self.parser.parse_next(i)
682        }
683    }
684}
685
686#[cfg(feature = "unstable-recover")]
687#[cfg(feature = "std")]
688fn retry_after_inner<P, R, I, O, E>(parser: &mut P, recover: &mut R, i: &mut I) -> Result<O, E>
689where
690    P: Parser<I, O, E>,
691    R: Parser<I, (), E>,
692    I: Stream,
693    I: Recover<E>,
694    E: ParserError<I> + FromRecoverableError<I, E>,
695{
696    loop {
697        let token_start = i.checkpoint();
698        let mut err = match parser.parse_next(i) {
699            Ok(o) => {
700                return Ok(o);
701            }
702            Err(e) if e.is_incomplete() => return Err(e),
703            Err(err) => err,
704        };
705        let err_start = i.checkpoint();
706        let err_start_eof_offset = i.eof_offset();
707        if recover.parse_next(i).is_ok() {
708            let i_eof_offset = i.eof_offset();
709            if err_start_eof_offset == i_eof_offset {
710                // Didn't advance so bubble the error up
711            } else if let Err(err_) = i.record_err(&token_start, &err_start, err) {
712                err = err_;
713            } else {
714                continue;
715            }
716        }
717
718        i.reset(&err_start);
719        err = E::from_recoverable_error(&token_start, &err_start, i, err);
720        return Err(err);
721    }
722}
723
724/// [`Parser`] implementation for [`Parser::resume_after`]
725#[cfg(feature = "unstable-recover")]
726#[cfg(feature = "std")]
727pub struct ResumeAfter<P, R, I, O, E>
728where
729    P: Parser<I, O, E>,
730    R: Parser<I, (), E>,
731    I: Stream,
732    I: Recover<E>,
733    E: ParserError<I> + FromRecoverableError<I, E>,
734{
735    pub(crate) parser: P,
736    pub(crate) recover: R,
737    pub(crate) marker: core::marker::PhantomData<(I, O, E)>,
738}
739
740#[cfg(feature = "unstable-recover")]
741#[cfg(feature = "std")]
742impl<P, R, I, O, E> Parser<I, Option<O>, E> for ResumeAfter<P, R, I, O, E>
743where
744    P: Parser<I, O, E>,
745    R: Parser<I, (), E>,
746    I: Stream,
747    I: Recover<E>,
748    E: ParserError<I> + FromRecoverableError<I, E>,
749{
750    #[inline(always)]
751    fn parse_next(&mut self, i: &mut I) -> Result<Option<O>, E> {
752        if I::is_recovery_supported() {
753            resume_after_inner(&mut self.parser, &mut self.recover, i)
754        } else {
755            self.parser.parse_next(i).map(Some)
756        }
757    }
758}
759
760#[cfg(feature = "unstable-recover")]
761#[cfg(feature = "std")]
762fn resume_after_inner<P, R, I, O, E>(
763    parser: &mut P,
764    recover: &mut R,
765    i: &mut I,
766) -> Result<Option<O>, E>
767where
768    P: Parser<I, O, E>,
769    R: Parser<I, (), E>,
770    I: Stream,
771    I: Recover<E>,
772    E: ParserError<I> + FromRecoverableError<I, E>,
773{
774    let token_start = i.checkpoint();
775    let mut err = match parser.parse_next(i) {
776        Ok(o) => {
777            return Ok(Some(o));
778        }
779        Err(e) if e.is_incomplete() => return Err(e),
780        Err(err) => err,
781    };
782    let err_start = i.checkpoint();
783    if recover.parse_next(i).is_ok() {
784        if let Err(err_) = i.record_err(&token_start, &err_start, err) {
785            err = err_;
786        } else {
787            return Ok(None);
788        }
789    }
790
791    i.reset(&err_start);
792    err = FromRecoverableError::from_recoverable_error(&token_start, &err_start, i, err);
793    Err(err)
794}
winnow/combinator/impls.rs

winnow/combinator/
impls.rs
