winnow/combinator/
impls.rs

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

winnow/combinator/
impls.rs
