winnow/combinator/
parser.rs

Help
1use crate::combinator::trace;
2use crate::combinator::trace_result;
3#[cfg(feature = "unstable-recover")]
4use crate::error::FromRecoverableError;
5use crate::error::{AddContext, ErrMode, ErrorKind, FromExternalError, ParserError};
6use crate::lib::std::borrow::Borrow;
7use crate::lib::std::ops::Range;
8#[cfg(feature = "unstable-recover")]
9use crate::stream::Recover;
10use crate::stream::StreamIsPartial;
11use crate::stream::{Location, Stream};
12use crate::*;
13
14/// Implementation of [`Parser::by_ref`]
15#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
16pub struct ByRef<'p, P> {
17    p: &'p mut P,
18}
19
20impl<'p, P> ByRef<'p, P> {
21    #[inline(always)]
22    pub(crate) fn new(p: &'p mut P) -> Self {
23        Self { p }
24    }
25}
26
27impl<'p, I, O, E, P> Parser<I, O, E> for ByRef<'p, P>
28where
29    P: Parser<I, O, E>,
30{
31    #[inline(always)]
32    fn parse_next(&mut self, i: &mut I) -> PResult<O, E> {
33        self.p.parse_next(i)
34    }
35}
36
37/// Implementation of [`Parser::map`]
38#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
39pub struct Map<F, G, I, O, O2, E>
40where
41    F: Parser<I, O, E>,
42    G: FnMut(O) -> O2,
43{
44    parser: F,
45    map: G,
46    i: core::marker::PhantomData<I>,
47    o: core::marker::PhantomData<O>,
48    o2: core::marker::PhantomData<O2>,
49    e: core::marker::PhantomData<E>,
50}
51
52impl<F, G, I, O, O2, E> Map<F, G, I, O, O2, E>
53where
54    F: Parser<I, O, E>,
55    G: FnMut(O) -> O2,
56{
57    #[inline(always)]
58    pub(crate) fn new(parser: F, map: G) -> Self {
59        Self {
60            parser,
61            map,
62            i: Default::default(),
63            o: Default::default(),
64            o2: Default::default(),
65            e: Default::default(),
66        }
67    }
68}
69
70impl<F, G, I, O, O2, E> Parser<I, O2, E> for Map<F, G, I, O, O2, E>
71where
72    F: Parser<I, O, E>,
73    G: FnMut(O) -> O2,
74{
75    #[inline]
76    fn parse_next(&mut self, i: &mut I) -> PResult<O2, E> {
77        match self.parser.parse_next(i) {
78            Err(e) => Err(e),
79            Ok(o) => Ok((self.map)(o)),
80        }
81    }
82}
83
84/// Implementation of [`Parser::try_map`]
85#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
86pub struct TryMap<F, G, I, O, O2, E, E2>
87where
88    F: Parser<I, O, E>,
89    G: FnMut(O) -> Result<O2, E2>,
90    I: Stream,
91    E: FromExternalError<I, E2>,
92{
93    parser: F,
94    map: G,
95    i: core::marker::PhantomData<I>,
96    o: core::marker::PhantomData<O>,
97    o2: core::marker::PhantomData<O2>,
98    e: core::marker::PhantomData<E>,
99    e2: core::marker::PhantomData<E2>,
100}
101
102impl<F, G, I, O, O2, E, E2> TryMap<F, G, I, O, O2, E, E2>
103where
104    F: Parser<I, O, E>,
105    G: FnMut(O) -> Result<O2, E2>,
106    I: Stream,
107    E: FromExternalError<I, E2>,
108{
109    #[inline(always)]
110    pub(crate) fn new(parser: F, map: G) -> Self {
111        Self {
112            parser,
113            map,
114            i: Default::default(),
115            o: Default::default(),
116            o2: Default::default(),
117            e: Default::default(),
118            e2: Default::default(),
119        }
120    }
121}
122
123impl<F, G, I, O, O2, E, E2> Parser<I, O2, E> for TryMap<F, G, I, O, O2, E, E2>
124where
125    F: Parser<I, O, E>,
126    G: FnMut(O) -> Result<O2, E2>,
127    I: Stream,
128    E: FromExternalError<I, E2>,
129{
130    #[inline]
131    fn parse_next(&mut self, input: &mut I) -> PResult<O2, E> {
132        let start = input.checkpoint();
133        let o = self.parser.parse_next(input)?;
134        let res = (self.map)(o).map_err(|err| {
135            input.reset(start);
136            ErrMode::from_external_error(input, ErrorKind::Verify, err)
137        });
138        trace_result("verify", &res);
139        res
140    }
141}
142
143/// Implementation of [`Parser::verify_map`]
144#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
145pub struct VerifyMap<F, G, I, O, O2, E>
146where
147    F: Parser<I, O, E>,
148    G: FnMut(O) -> Option<O2>,
149    I: Stream,
150    E: ParserError<I>,
151{
152    parser: F,
153    map: G,
154    i: core::marker::PhantomData<I>,
155    o: core::marker::PhantomData<O>,
156    o2: core::marker::PhantomData<O2>,
157    e: core::marker::PhantomData<E>,
158}
159
160impl<F, G, I, O, O2, E> VerifyMap<F, G, I, O, O2, E>
161where
162    F: Parser<I, O, E>,
163    G: FnMut(O) -> Option<O2>,
164    I: Stream,
165    E: ParserError<I>,
166{
167    #[inline(always)]
168    pub(crate) fn new(parser: F, map: G) -> Self {
169        Self {
170            parser,
171            map,
172            i: Default::default(),
173            o: Default::default(),
174            o2: Default::default(),
175            e: Default::default(),
176        }
177    }
178}
179
180impl<F, G, I, O, O2, E> Parser<I, O2, E> for VerifyMap<F, G, I, O, O2, E>
181where
182    F: Parser<I, O, E>,
183    G: FnMut(O) -> Option<O2>,
184    I: Stream,
185    E: ParserError<I>,
186{
187    #[inline]
188    fn parse_next(&mut self, input: &mut I) -> PResult<O2, E> {
189        let start = input.checkpoint();
190        let o = self.parser.parse_next(input)?;
191        let res = (self.map)(o).ok_or_else(|| {
192            input.reset(start);
193            ErrMode::from_error_kind(input, ErrorKind::Verify)
194        });
195        trace_result("verify", &res);
196        res
197    }
198}
199
200/// Implementation of [`Parser::and_then`]
201#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
202pub struct AndThen<F, G, I, O, O2, E>
203where
204    F: Parser<I, O, E>,
205    G: Parser<O, O2, E>,
206    O: StreamIsPartial,
207    I: Stream,
208{
209    outer: F,
210    inner: G,
211    i: core::marker::PhantomData<I>,
212    o: core::marker::PhantomData<O>,
213    o2: core::marker::PhantomData<O2>,
214    e: core::marker::PhantomData<E>,
215}
216
217impl<F, G, I, O, O2, E> AndThen<F, G, I, O, O2, E>
218where
219    F: Parser<I, O, E>,
220    G: Parser<O, O2, E>,
221    O: StreamIsPartial,
222    I: Stream,
223{
224    #[inline(always)]
225    pub(crate) fn new(outer: F, inner: G) -> Self {
226        Self {
227            outer,
228            inner,
229            i: Default::default(),
230            o: Default::default(),
231            o2: Default::default(),
232            e: Default::default(),
233        }
234    }
235}
236
237impl<F, G, I, O, O2, E> Parser<I, O2, E> for AndThen<F, G, I, O, O2, E>
238where
239    F: Parser<I, O, E>,
240    G: Parser<O, O2, E>,
241    O: StreamIsPartial,
242    I: Stream,
243{
244    #[inline(always)]
245    fn parse_next(&mut self, i: &mut I) -> PResult<O2, E> {
246        let start = i.checkpoint();
247        let mut o = self.outer.parse_next(i)?;
248        let _ = o.complete();
249        let o2 = self.inner.parse_next(&mut o).map_err(|err| {
250            i.reset(start);
251            err
252        })?;
253        Ok(o2)
254    }
255}
256
257/// Implementation of [`Parser::parse_to`]
258#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
259pub struct ParseTo<P, I, O, O2, E>
260where
261    P: Parser<I, O, E>,
262    I: Stream,
263    O: crate::stream::ParseSlice<O2>,
264    E: ParserError<I>,
265{
266    p: P,
267    i: core::marker::PhantomData<I>,
268    o: core::marker::PhantomData<O>,
269    o2: core::marker::PhantomData<O2>,
270    e: core::marker::PhantomData<E>,
271}
272
273impl<P, I, O, O2, E> ParseTo<P, I, O, O2, E>
274where
275    P: Parser<I, O, E>,
276    I: Stream,
277    O: crate::stream::ParseSlice<O2>,
278    E: ParserError<I>,
279{
280    #[inline(always)]
281    pub(crate) fn new(p: P) -> Self {
282        Self {
283            p,
284            i: Default::default(),
285            o: Default::default(),
286            o2: Default::default(),
287            e: Default::default(),
288        }
289    }
290}
291
292impl<P, I, O, O2, E> Parser<I, O2, E> for ParseTo<P, I, O, O2, E>
293where
294    P: Parser<I, O, E>,
295    I: Stream,
296    O: crate::stream::ParseSlice<O2>,
297    E: ParserError<I>,
298{
299    #[inline]
300    fn parse_next(&mut self, i: &mut I) -> PResult<O2, E> {
301        let start = i.checkpoint();
302        let o = self.p.parse_next(i)?;
303        let res = o.parse_slice().ok_or_else(|| {
304            i.reset(start);
305            ErrMode::from_error_kind(i, ErrorKind::Verify)
306        });
307        trace_result("verify", &res);
308        res
309    }
310}
311
312/// Implementation of [`Parser::flat_map`]
313#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
314pub struct FlatMap<F, G, H, I, O, O2, E>
315where
316    F: Parser<I, O, E>,
317    G: FnMut(O) -> H,
318    H: Parser<I, O2, E>,
319{
320    f: F,
321    g: G,
322    h: core::marker::PhantomData<H>,
323    i: core::marker::PhantomData<I>,
324    o: core::marker::PhantomData<O>,
325    o2: core::marker::PhantomData<O2>,
326    e: core::marker::PhantomData<E>,
327}
328
329impl<F, G, H, I, O, O2, E> FlatMap<F, G, H, I, O, O2, E>
330where
331    F: Parser<I, O, E>,
332    G: FnMut(O) -> H,
333    H: Parser<I, O2, E>,
334{
335    #[inline(always)]
336    pub(crate) fn new(f: F, g: G) -> Self {
337        Self {
338            f,
339            g,
340            h: Default::default(),
341            i: Default::default(),
342            o: Default::default(),
343            o2: Default::default(),
344            e: Default::default(),
345        }
346    }
347}
348
349impl<F, G, H, I, O, O2, E> Parser<I, O2, E> for FlatMap<F, G, H, I, O, O2, E>
350where
351    F: Parser<I, O, E>,
352    G: FnMut(O) -> H,
353    H: Parser<I, O2, E>,
354{
355    #[inline(always)]
356    fn parse_next(&mut self, i: &mut I) -> PResult<O2, E> {
357        let o = self.f.parse_next(i)?;
358        (self.g)(o).parse_next(i)
359    }
360}
361
362/// Implementation of [`Parser::complete_err`]
363#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
364pub struct CompleteErr<F> {
365    f: F,
366}
367
368impl<F> CompleteErr<F> {
369    #[inline(always)]
370    pub(crate) fn new(f: F) -> Self {
371        Self { f }
372    }
373}
374
375impl<F, I, O, E> Parser<I, O, E> for CompleteErr<F>
376where
377    I: Stream,
378    F: Parser<I, O, E>,
379    E: ParserError<I>,
380{
381    #[inline]
382    fn parse_next(&mut self, input: &mut I) -> PResult<O, E> {
383        trace("complete_err", |input: &mut I| {
384            match (self.f).parse_next(input) {
385                Err(ErrMode::Incomplete(_)) => {
386                    Err(ErrMode::from_error_kind(input, ErrorKind::Complete))
387                }
388                rest => rest,
389            }
390        })
391        .parse_next(input)
392    }
393}
394
395/// Implementation of [`Parser::verify`]
396#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
397pub struct Verify<F, G, I, O, O2, E>
398where
399    F: Parser<I, O, E>,
400    G: FnMut(&O2) -> bool,
401    I: Stream,
402    O: Borrow<O2>,
403    O2: ?Sized,
404    E: ParserError<I>,
405{
406    parser: F,
407    filter: G,
408    i: core::marker::PhantomData<I>,
409    o: core::marker::PhantomData<O>,
410    o2: core::marker::PhantomData<O2>,
411    e: core::marker::PhantomData<E>,
412}
413
414impl<F, G, I, O, O2, E> Verify<F, G, I, O, O2, E>
415where
416    F: Parser<I, O, E>,
417    G: FnMut(&O2) -> bool,
418    I: Stream,
419    O: Borrow<O2>,
420    O2: ?Sized,
421    E: ParserError<I>,
422{
423    #[inline(always)]
424    pub(crate) fn new(parser: F, filter: G) -> Self {
425        Self {
426            parser,
427            filter,
428            i: Default::default(),
429            o: Default::default(),
430            o2: Default::default(),
431            e: Default::default(),
432        }
433    }
434}
435
436impl<F, G, I, O, O2, E> Parser<I, O, E> for Verify<F, G, I, O, O2, E>
437where
438    F: Parser<I, O, E>,
439    G: FnMut(&O2) -> bool,
440    I: Stream,
441    O: Borrow<O2>,
442    O2: ?Sized,
443    E: ParserError<I>,
444{
445    #[inline]
446    fn parse_next(&mut self, input: &mut I) -> PResult<O, E> {
447        let start = input.checkpoint();
448        let o = self.parser.parse_next(input)?;
449        let res = (self.filter)(o.borrow()).then_some(o).ok_or_else(|| {
450            input.reset(start);
451            ErrMode::from_error_kind(input, ErrorKind::Verify)
452        });
453        trace_result("verify", &res);
454        res
455    }
456}
457
458/// Implementation of [`Parser::value`]
459#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
460pub struct Value<F, I, O, O2, E>
461where
462    F: Parser<I, O, E>,
463    O2: Clone,
464{
465    parser: F,
466    val: O2,
467    i: core::marker::PhantomData<I>,
468    o: core::marker::PhantomData<O>,
469    e: core::marker::PhantomData<E>,
470}
471
472impl<F, I, O, O2, E> Value<F, I, O, O2, E>
473where
474    F: Parser<I, O, E>,
475    O2: Clone,
476{
477    #[inline(always)]
478    pub(crate) fn new(parser: F, val: O2) -> Self {
479        Self {
480            parser,
481            val,
482            i: Default::default(),
483            o: Default::default(),
484            e: Default::default(),
485        }
486    }
487}
488
489impl<F, I, O, O2, E> Parser<I, O2, E> for Value<F, I, O, O2, E>
490where
491    F: Parser<I, O, E>,
492    O2: Clone,
493{
494    #[inline]
495    fn parse_next(&mut self, input: &mut I) -> PResult<O2, E> {
496        (self.parser).parse_next(input).map(|_| self.val.clone())
497    }
498}
499
500/// Implementation of [`Parser::default_value`]
501#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
502pub struct DefaultValue<F, I, O, O2, E>
503where
504    F: Parser<I, O, E>,
505    O2: core::default::Default,
506{
507    parser: F,
508    o2: core::marker::PhantomData<O2>,
509    i: core::marker::PhantomData<I>,
510    o: core::marker::PhantomData<O>,
511    e: core::marker::PhantomData<E>,
512}
513
514impl<F, I, O, O2, E> DefaultValue<F, I, O, O2, E>
515where
516    F: Parser<I, O, E>,
517    O2: core::default::Default,
518{
519    #[inline(always)]
520    pub(crate) fn new(parser: F) -> Self {
521        Self {
522            parser,
523            o2: Default::default(),
524            i: Default::default(),
525            o: Default::default(),
526            e: Default::default(),
527        }
528    }
529}
530
531impl<F, I, O, O2, E> Parser<I, O2, E> for DefaultValue<F, I, O, O2, E>
532where
533    F: Parser<I, O, E>,
534    O2: core::default::Default,
535{
536    #[inline]
537    fn parse_next(&mut self, input: &mut I) -> PResult<O2, E> {
538        (self.parser).parse_next(input).map(|_| O2::default())
539    }
540}
541
542/// Implementation of [`Parser::void`]
543#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
544pub struct Void<F, I, O, E>
545where
546    F: Parser<I, O, E>,
547{
548    parser: F,
549    i: core::marker::PhantomData<I>,
550    o: core::marker::PhantomData<O>,
551    e: core::marker::PhantomData<E>,
552}
553
554impl<F, I, O, E> Void<F, I, O, E>
555where
556    F: Parser<I, O, E>,
557{
558    #[inline(always)]
559    pub(crate) fn new(parser: F) -> Self {
560        Self {
561            parser,
562            i: Default::default(),
563            o: Default::default(),
564            e: Default::default(),
565        }
566    }
567}
568
569impl<F, I, O, E> Parser<I, (), E> for Void<F, I, O, E>
570where
571    F: Parser<I, O, E>,
572{
573    #[inline(always)]
574    fn parse_next(&mut self, input: &mut I) -> PResult<(), E> {
575        (self.parser).parse_next(input).map(|_| ())
576    }
577}
578
579/// Implementation of [`Parser::recognize`]
580#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
581pub struct Recognize<F, I, O, E>
582where
583    F: Parser<I, O, E>,
584    I: Stream,
585{
586    parser: F,
587    i: core::marker::PhantomData<I>,
588    o: core::marker::PhantomData<O>,
589    e: core::marker::PhantomData<E>,
590}
591
592impl<F, I, O, E> Recognize<F, I, O, E>
593where
594    F: Parser<I, O, E>,
595    I: Stream,
596{
597    #[inline(always)]
598    pub(crate) fn new(parser: F) -> Self {
599        Self {
600            parser,
601            i: Default::default(),
602            o: Default::default(),
603            e: Default::default(),
604        }
605    }
606}
607
608impl<I, O, E, F> Parser<I, <I as Stream>::Slice, E> for Recognize<F, I, O, E>
609where
610    F: Parser<I, O, E>,
611    I: Stream,
612{
613    #[inline]
614    fn parse_next(&mut self, input: &mut I) -> PResult<<I as Stream>::Slice, E> {
615        let checkpoint = input.checkpoint();
616        match (self.parser).parse_next(input) {
617            Ok(_) => {
618                let offset = input.offset_from(&checkpoint);
619                input.reset(checkpoint);
620                let recognized = input.next_slice(offset);
621                Ok(recognized)
622            }
623            Err(e) => Err(e),
624        }
625    }
626}
627
628/// Implementation of [`Parser::with_recognized`]
629#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
630pub struct WithRecognized<F, I, O, E>
631where
632    F: Parser<I, O, E>,
633    I: Stream,
634{
635    parser: F,
636    i: core::marker::PhantomData<I>,
637    o: core::marker::PhantomData<O>,
638    e: core::marker::PhantomData<E>,
639}
640
641impl<F, I, O, E> WithRecognized<F, I, O, E>
642where
643    F: Parser<I, O, E>,
644    I: Stream,
645{
646    #[inline(always)]
647    pub(crate) fn new(parser: F) -> Self {
648        Self {
649            parser,
650            i: Default::default(),
651            o: Default::default(),
652            e: Default::default(),
653        }
654    }
655}
656
657impl<F, I, O, E> Parser<I, (O, <I as Stream>::Slice), E> for WithRecognized<F, I, O, E>
658where
659    F: Parser<I, O, E>,
660    I: Stream,
661{
662    #[inline]
663    fn parse_next(&mut self, input: &mut I) -> PResult<(O, <I as Stream>::Slice), E> {
664        let checkpoint = input.checkpoint();
665        match (self.parser).parse_next(input) {
666            Ok(result) => {
667                let offset = input.offset_from(&checkpoint);
668                input.reset(checkpoint);
669                let recognized = input.next_slice(offset);
670                Ok((result, recognized))
671            }
672            Err(e) => Err(e),
673        }
674    }
675}
676
677/// Implementation of [`Parser::span`]
678#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
679pub struct Span<F, I, O, E>
680where
681    F: Parser<I, O, E>,
682    I: Stream + Location,
683{
684    parser: F,
685    i: core::marker::PhantomData<I>,
686    o: core::marker::PhantomData<O>,
687    e: core::marker::PhantomData<E>,
688}
689
690impl<F, I, O, E> Span<F, I, O, E>
691where
692    F: Parser<I, O, E>,
693    I: Stream + Location,
694{
695    #[inline(always)]
696    pub(crate) fn new(parser: F) -> Self {
697        Self {
698            parser,
699            i: Default::default(),
700            o: Default::default(),
701            e: Default::default(),
702        }
703    }
704}
705
706impl<I, O, E, F> Parser<I, Range<usize>, E> for Span<F, I, O, E>
707where
708    F: Parser<I, O, E>,
709    I: Stream + Location,
710{
711    #[inline]
712    fn parse_next(&mut self, input: &mut I) -> PResult<Range<usize>, E> {
713        let start = input.location();
714        self.parser.parse_next(input).map(move |_| {
715            let end = input.location();
716            start..end
717        })
718    }
719}
720
721/// Implementation of [`Parser::with_span`]
722#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
723pub struct WithSpan<F, I, O, E>
724where
725    F: Parser<I, O, E>,
726    I: Stream + Location,
727{
728    parser: F,
729    i: core::marker::PhantomData<I>,
730    o: core::marker::PhantomData<O>,
731    e: core::marker::PhantomData<E>,
732}
733
734impl<F, I, O, E> WithSpan<F, I, O, E>
735where
736    F: Parser<I, O, E>,
737    I: Stream + Location,
738{
739    #[inline(always)]
740    pub(crate) fn new(parser: F) -> Self {
741        Self {
742            parser,
743            i: Default::default(),
744            o: Default::default(),
745            e: Default::default(),
746        }
747    }
748}
749
750impl<F, I, O, E> Parser<I, (O, Range<usize>), E> for WithSpan<F, I, O, E>
751where
752    F: Parser<I, O, E>,
753    I: Stream + Location,
754{
755    #[inline]
756    fn parse_next(&mut self, input: &mut I) -> PResult<(O, Range<usize>), E> {
757        let start = input.location();
758        self.parser.parse_next(input).map(move |output| {
759            let end = input.location();
760            (output, (start..end))
761        })
762    }
763}
764
765/// Implementation of [`Parser::output_into`]
766#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
767pub struct OutputInto<F, I, O, O2, E>
768where
769    F: Parser<I, O, E>,
770    O: Into<O2>,
771{
772    parser: F,
773    i: core::marker::PhantomData<I>,
774    o: core::marker::PhantomData<O>,
775    o2: core::marker::PhantomData<O2>,
776    e: core::marker::PhantomData<E>,
777}
778
779impl<F, I, O, O2, E> OutputInto<F, I, O, O2, E>
780where
781    F: Parser<I, O, E>,
782    O: Into<O2>,
783{
784    #[inline(always)]
785    pub(crate) fn new(parser: F) -> Self {
786        Self {
787            parser,
788            i: Default::default(),
789            o: Default::default(),
790            o2: Default::default(),
791            e: Default::default(),
792        }
793    }
794}
795
796impl<F, I, O, O2, E> Parser<I, O2, E> for OutputInto<F, I, O, O2, E>
797where
798    F: Parser<I, O, E>,
799    O: Into<O2>,
800{
801    #[inline]
802    fn parse_next(&mut self, i: &mut I) -> PResult<O2, E> {
803        self.parser.parse_next(i).map(|o| o.into())
804    }
805}
806
807/// Implementation of [`Parser::err_into`]
808#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
809pub struct ErrInto<F, I, O, E, E2>
810where
811    F: Parser<I, O, E>,
812    E: Into<E2>,
813{
814    parser: F,
815    i: core::marker::PhantomData<I>,
816    o: core::marker::PhantomData<O>,
817    e: core::marker::PhantomData<E>,
818    e2: core::marker::PhantomData<E2>,
819}
820
821impl<F, I, O, E, E2> ErrInto<F, I, O, E, E2>
822where
823    F: Parser<I, O, E>,
824    E: Into<E2>,
825{
826    #[inline(always)]
827    pub(crate) fn new(parser: F) -> Self {
828        Self {
829            parser,
830            i: Default::default(),
831            o: Default::default(),
832            e: Default::default(),
833            e2: Default::default(),
834        }
835    }
836}
837
838impl<F, I, O, E, E2> Parser<I, O, E2> for ErrInto<F, I, O, E, E2>
839where
840    F: Parser<I, O, E>,
841    E: Into<E2>,
842{
843    #[inline]
844    fn parse_next(&mut self, i: &mut I) -> PResult<O, E2> {
845        match self.parser.parse_next(i) {
846            Ok(ok) => Ok(ok),
847            Err(ErrMode::Backtrack(e)) => Err(ErrMode::Backtrack(e.into())),
848            Err(ErrMode::Cut(e)) => Err(ErrMode::Cut(e.into())),
849            Err(ErrMode::Incomplete(e)) => Err(ErrMode::Incomplete(e)),
850        }
851    }
852}
853
854/// Implementation of [`Parser::context`]
855#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
856pub struct Context<F, I, O, E, C>
857where
858    F: Parser<I, O, E>,
859    I: Stream,
860    E: AddContext<I, C>,
861    C: Clone + crate::lib::std::fmt::Debug,
862{
863    parser: F,
864    context: C,
865    i: core::marker::PhantomData<I>,
866    o: core::marker::PhantomData<O>,
867    e: core::marker::PhantomData<E>,
868}
869
870impl<F, I, O, E, C> Context<F, I, O, E, C>
871where
872    F: Parser<I, O, E>,
873    I: Stream,
874    E: AddContext<I, C>,
875    C: Clone + crate::lib::std::fmt::Debug,
876{
877    #[inline(always)]
878    pub(crate) fn new(parser: F, context: C) -> Self {
879        Self {
880            parser,
881            context,
882            i: Default::default(),
883            o: Default::default(),
884            e: Default::default(),
885        }
886    }
887}
888
889impl<F, I, O, E, C> Parser<I, O, E> for Context<F, I, O, E, C>
890where
891    F: Parser<I, O, E>,
892    I: Stream,
893    E: AddContext<I, C>,
894    C: Clone + crate::lib::std::fmt::Debug,
895{
896    #[inline]
897    fn parse_next(&mut self, i: &mut I) -> PResult<O, E> {
898        #[cfg(feature = "debug")]
899        let name = format!("context={:?}", self.context);
900        #[cfg(not(feature = "debug"))]
901        let name = "context";
902        trace(name, move |i: &mut I| {
903            (self.parser)
904                .parse_next(i)
905                .map_err(|err| err.add_context(i, self.context.clone()))
906        })
907        .parse_next(i)
908    }
909}
910
911/// Implementation of [`Parser::retry_after`]
912#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
913#[cfg(feature = "unstable-recover")]
914pub struct RetryAfter<P, R, I, O, E>
915where
916    P: Parser<I, O, E>,
917    R: Parser<I, (), E>,
918    I: Stream,
919    I: Recover<E>,
920    E: FromRecoverableError<I, E>,
921{
922    parser: P,
923    recover: R,
924    i: core::marker::PhantomData<I>,
925    o: core::marker::PhantomData<O>,
926    e: core::marker::PhantomData<E>,
927}
928
929#[cfg(feature = "unstable-recover")]
930impl<P, R, I, O, E> RetryAfter<P, R, I, O, E>
931where
932    P: Parser<I, O, E>,
933    R: Parser<I, (), E>,
934    I: Stream,
935    I: Recover<E>,
936    E: FromRecoverableError<I, E>,
937{
938    #[inline(always)]
939    pub(crate) fn new(parser: P, recover: R) -> Self {
940        Self {
941            parser,
942            recover,
943            i: Default::default(),
944            o: Default::default(),
945            e: Default::default(),
946        }
947    }
948}
949
950#[cfg(feature = "unstable-recover")]
951impl<P, R, I, O, E> Parser<I, O, E> for RetryAfter<P, R, I, O, E>
952where
953    P: Parser<I, O, E>,
954    R: Parser<I, (), E>,
955    I: Stream,
956    I: Recover<E>,
957    E: FromRecoverableError<I, E>,
958{
959    #[inline(always)]
960    fn parse_next(&mut self, i: &mut I) -> PResult<O, E> {
961        if I::is_recovery_supported() {
962            retry_after_inner(&mut self.parser, &mut self.recover, i)
963        } else {
964            self.parser.parse_next(i)
965        }
966    }
967}
968
969#[cfg(feature = "unstable-recover")]
970fn retry_after_inner<P, R, I, O, E>(parser: &mut P, recover: &mut R, i: &mut I) -> PResult<O, E>
971where
972    P: Parser<I, O, E>,
973    R: Parser<I, (), E>,
974    I: Stream,
975    I: Recover<E>,
976    E: FromRecoverableError<I, E>,
977{
978    loop {
979        let token_start = i.checkpoint();
980        let mut err = match parser.parse_next(i) {
981            Ok(o) => {
982                return Ok(o);
983            }
984            Err(ErrMode::Incomplete(e)) => return Err(ErrMode::Incomplete(e)),
985            Err(err) => err,
986        };
987        let err_start = i.checkpoint();
988        let err_start_eof_offset = i.eof_offset();
989        if recover.parse_next(i).is_ok() {
990            let i_eof_offset = i.eof_offset();
991            if err_start_eof_offset == i_eof_offset {
992                // Didn't advance so bubble the error up
993            } else if let Err(err_) = i.record_err(&token_start, &err_start, err) {
994                err = err_;
995            } else {
996                continue;
997            }
998        }
999
1000        i.reset(err_start.clone());
1001        err = err.map(|err| E::from_recoverable_error(&token_start, &err_start, i, err));
1002        return Err(err);
1003    }
1004}
1005
1006/// Implementation of [`Parser::resume_after`]
1007#[cfg(feature = "unstable-recover")]
1008#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
1009pub struct ResumeAfter<P, R, I, O, E>
1010where
1011    P: Parser<I, O, E>,
1012    R: Parser<I, (), E>,
1013    I: Stream,
1014    I: Recover<E>,
1015    E: FromRecoverableError<I, E>,
1016{
1017    parser: P,
1018    recover: R,
1019    i: core::marker::PhantomData<I>,
1020    o: core::marker::PhantomData<O>,
1021    e: core::marker::PhantomData<E>,
1022}
1023
1024#[cfg(feature = "unstable-recover")]
1025impl<P, R, I, O, E> ResumeAfter<P, R, I, O, E>
1026where
1027    P: Parser<I, O, E>,
1028    R: Parser<I, (), E>,
1029    I: Stream,
1030    I: Recover<E>,
1031    E: FromRecoverableError<I, E>,
1032{
1033    #[inline(always)]
1034    pub(crate) fn new(parser: P, recover: R) -> Self {
1035        Self {
1036            parser,
1037            recover,
1038            i: Default::default(),
1039            o: Default::default(),
1040            e: Default::default(),
1041        }
1042    }
1043}
1044
1045#[cfg(feature = "unstable-recover")]
1046impl<P, R, I, O, E> Parser<I, Option<O>, E> for ResumeAfter<P, R, I, O, E>
1047where
1048    P: Parser<I, O, E>,
1049    R: Parser<I, (), E>,
1050    I: Stream,
1051    I: Recover<E>,
1052    E: FromRecoverableError<I, E>,
1053{
1054    #[inline(always)]
1055    fn parse_next(&mut self, i: &mut I) -> PResult<Option<O>, E> {
1056        if I::is_recovery_supported() {
1057            resume_after_inner(&mut self.parser, &mut self.recover, i)
1058        } else {
1059            self.parser.parse_next(i).map(Some)
1060        }
1061    }
1062}
1063
1064#[cfg(feature = "unstable-recover")]
1065fn resume_after_inner<P, R, I, O, E>(
1066    parser: &mut P,
1067    recover: &mut R,
1068    i: &mut I,
1069) -> PResult<Option<O>, E>
1070where
1071    P: Parser<I, O, E>,
1072    R: Parser<I, (), E>,
1073    I: Stream,
1074    I: Recover<E>,
1075    E: FromRecoverableError<I, E>,
1076{
1077    let token_start = i.checkpoint();
1078    let mut err = match parser.parse_next(i) {
1079        Ok(o) => {
1080            return Ok(Some(o));
1081        }
1082        Err(ErrMode::Incomplete(e)) => return Err(ErrMode::Incomplete(e)),
1083        Err(err) => err,
1084    };
1085    let err_start = i.checkpoint();
1086    if recover.parse_next(i).is_ok() {
1087        if let Err(err_) = i.record_err(&token_start, &err_start, err) {
1088            err = err_;
1089        } else {
1090            return Ok(None);
1091        }
1092    }
1093
1094    i.reset(err_start.clone());
1095    err = err.map(|err| E::from_recoverable_error(&token_start, &err_start, i, err));
1096    Err(err)
1097}
winnow/combinator/parser.rs

winnow/combinator/
parser.rs
