edg-l/edlang
1
1
Fork 0
mirror of https://github.com/edg-l/edlang.git synced 2024-11-23 00:18:24 +00:00
Code Issues Packages Projects Releases Wiki Activity
edlang/winnow/trait.Parser.html
edg-l e1cb4115d9 deploy: 22498719e1
2024-03-11 08:39:13 +00:00

870 lines
203 KiB
HTML
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Core trait for parsing"><title>Parser in winnow - Rust</title><link rel="preload" as="font" type="font/woff2" crossorigin href="../static.files/SourceSerif4-Regular-46f98efaafac5295.ttf.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../static.files/FiraSans-Regular-018c141bf0843ffd.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../static.files/FiraSans-Medium-8f9a781e4970d388.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../static.files/SourceCodePro-Regular-562dcc5011b6de7d.ttf.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../static.files/SourceCodePro-Semibold-d899c5a5c4aeb14a.ttf.woff2"><link rel="stylesheet" href="../static.files/normalize-76eba96aa4d2e634.css"><link rel="stylesheet" href="../static.files/rustdoc-ac92e1bbe349e143.css"><meta name="rustdoc-vars" data-root-path="../" data-static-root-path="../static.files/" data-current-crate="winnow" data-themes="" data-resource-suffix="" data-rustdoc-version="1.76.0 (07dca489a 2024-02-04)" data-channel="1.76.0" data-search-js="search-2b6ce74ff89ae146.js" data-settings-js="settings-4313503d2e1961c2.js" ><script src="../static.files/storage-f2adc0d6ca4d09fb.js"></script><script defer src="sidebar-items.js"></script><script defer src="../static.files/main-305769736d49e732.js"></script><noscript><link rel="stylesheet" href="../static.files/noscript-feafe1bb7466e4bd.css"></noscript><link rel="alternate icon" type="image/png" href="../static.files/favicon-16x16-8b506e7a72182f1c.png"><link rel="alternate icon" type="image/png" href="../static.files/favicon-32x32-422f7d1d52889060.png"><link rel="icon" type="image/svg+xml" href="../static.files/favicon-2c020d218678b618.svg"></head><body class="rustdoc trait"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="mobile-topbar"><button class="sidebar-menu-toggle">&#9776;</button></nav><nav class="sidebar"><div class="sidebar-crate"><h2><a href="../winnow/index.html">winnow</a><span class="version">0.6.5</span></h2></div><h2 class="location"><a href="#">Parser</a></h2><div class="sidebar-elems"><section><h3><a href="#required-methods">Required Methods</a></h3><ul class="block"><li><a href="#tymethod.parse_next">parse_next</a></li></ul><h3><a href="#provided-methods">Provided Methods</a></h3><ul class="block"><li><a href="#method.and_then">and_then</a></li><li><a href="#method.by_ref">by_ref</a></li><li><a href="#method.complete_err">complete_err</a></li><li><a href="#method.context">context</a></li><li><a href="#method.default_value">default_value</a></li><li><a href="#method.err_into">err_into</a></li><li><a href="#method.flat_map">flat_map</a></li><li><a href="#method.map">map</a></li><li><a href="#method.output_into">output_into</a></li><li><a href="#method.parse">parse</a></li><li><a href="#method.parse_peek">parse_peek</a></li><li><a href="#method.parse_to">parse_to</a></li><li><a href="#method.recognize">recognize</a></li><li><a href="#method.span">span</a></li><li><a href="#method.try_map">try_map</a></li><li><a href="#method.value">value</a></li><li><a href="#method.verify">verify</a></li><li><a href="#method.verify_map">verify_map</a></li><li><a href="#method.void">void</a></li><li><a href="#method.with_recognized">with_recognized</a></li><li><a href="#method.with_span">with_span</a></li></ul><h3><a href="#foreign-impls">Implementations on Foreign Types</a></h3><ul class="block"><li><a href="#impl-Parser%3CI,+%3CI+as+Stream%3E::Slice,+E%3E-for-%26%5Bu8;+N%5D">&amp;&#x27;s [u8; N]</a></li><li><a href="#impl-Parser%3CI,+%3CI+as+Stream%3E::Slice,+E%3E-for-%26%5Bu8%5D">&amp;&#x27;s [u8]</a></li><li><a href="#impl-Parser%3CI,+%3CI+as+Stream%3E::Slice,+E%3E-for-%26str">&amp;&#x27;s str</a></li><li><a href="#impl-Parser%3CI,+(),+E%3E-for-()">()</a></li><li><a href="#impl-Parser%3CI,+(O1,+O2),+E%3E-for-(P1,+P2)">(P1, P2)</a></li><li><a href="#impl-Parser%3CI,+(O1,+O2,+O3),+E%3E-for-(P1,+P2,+P3)">(P1, P2, P3)</a></li><li><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4),+E%3E-for-(P1,+P2,+P3,+P4)">(P1, P2, P3, P4)</a></li><li><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5),+E%3E-for-(P1,+P2,+P3,+P4,+P5)">(P1, P2, P3, P4, P5)</a></li><li><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6)">(P1, P2, P3, P4, P5, P6)</a></li><li><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7)">(P1, P2, P3, P4, P5, P6, P7)</a></li><li><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8)">(P1, P2, P3, P4, P5, P6, P7, P8)</a></li><li><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9)">(P1, P2, P3, P4, P5, P6, P7, P8, P9)</a></li><li><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10)">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)</a></li><li><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11)">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11)</a></li><li><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12)">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12)</a></li><li><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13)">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13)</a></li><li><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14)">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14)</a></li><li><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15)">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15)</a></li><li><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15,+O16),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15,+P16)">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16)</a></li><li><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15,+O16,+O17),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15,+P16,+P17)">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17)</a></li><li><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15,+O16,+O17,+O18),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15,+P16,+P17,+P18)">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18)</a></li><li><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15,+O16,+O17,+O18,+O19),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15,+P16,+P17,+P18,+P19)">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)</a></li><li><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15,+O16,+O17,+O18,+O19,+O20),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15,+P16,+P17,+P18,+P19,+P20)">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)</a></li><li><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15,+O16,+O17,+O18,+O19,+O20,+O21),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15,+P16,+P17,+P18,+P19,+P20,+P21)">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21)</a></li><li><a href="#impl-Parser%3CI,+(O1,),+E%3E-for-(P1,)">(P1,)</a></li><li><a href="#impl-Parser%3CI,+O,+E%3E-for-Box%3Cdyn+Parser%3CI,+O,+E%3E%3E">Box&lt;dyn Parser&lt;I, O, E&gt; + &#x27;a&gt;</a></li><li><a href="#impl-Parser%3CI,+char,+E%3E-for-char">char</a></li><li><a href="#impl-Parser%3CI,+u8,+E%3E-for-u8">u8</a></li></ul><h3><a href="#trait-implementations">Trait Implementations</a></h3><ul class="block trait-implementation"><li><a href="#impl-Parser%3CI,+O,+E%3E-for-Box%3Cdyn+Parser%3CI,+O,+E%3E%3E">Parser&lt;I, O, E&gt;</a></li></ul><h3><a href="#implementors">Implementors</a></h3></section><h2><a href="index.html">In crate winnow</a></h2></div></nav><div class="sidebar-resizer"></div>
<main><div class="width-limiter"><nav class="sub"><form class="search-form"><span></span><div id="sidebar-button" tabindex="-1"><a href="../winnow/all.html" title="show sidebar"></a></div><input class="search-input" name="search" aria-label="Run search in the documentation" autocomplete="off" spellcheck="false" placeholder="Click or press ‘S’ to search, ‘?’ for more options…" type="search"><div id="help-button" tabindex="-1"><a href="../help.html" title="help">?</a></div><div id="settings-menu" tabindex="-1"><a href="../settings.html" title="settings"><img width="22" height="22" alt="Change settings" src="../static.files/wheel-7b819b6101059cd0.svg"></a></div></form></nav><section id="main-content" class="content"><div class="main-heading"><h1>Trait <a href="index.html">winnow</a>::<wbr><a class="trait" href="#">Parser</a><button id="copy-path" title="Copy item path to clipboard"><img src="../static.files/clipboard-7571035ce49a181d.svg" width="19" height="18" alt="Copy item path"></button></h1><span class="out-of-band"><a class="src" href="../src/winnow/parser.rs.html#46-706">source</a> · <button id="toggle-all-docs" title="collapse all docs">[<span>&#x2212;</span>]</button></span></div><pre class="rust item-decl"><code>pub trait Parser&lt;I, O, E&gt; {
<details class="toggle type-contents-toggle"><summary class="hideme"><span>Show 22 methods</span></summary> // Required method
fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(&amp;mut self, input: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;O, E&gt;;
// Provided methods
fn <a href="#method.parse" class="fn">parse</a>(&amp;mut self, input: I) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;O, <a class="struct" href="error/struct.ParseError.html" title="struct winnow::error::ParseError">ParseError</a>&lt;I, E&gt;&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a> + <a class="trait" href="stream/trait.StreamIsPartial.html" title="trait winnow::stream::StreamIsPartial">StreamIsPartial</a> + <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>,
E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;</span> { ... }
<span class="item-spacer"></span> fn <a href="#method.parse_peek" class="fn">parse_peek</a>(&amp;mut self, input: I) -&gt; <a class="type" href="error/type.IResult.html" title="type winnow::error::IResult">IResult</a>&lt;I, O, E&gt; { ... }
<span class="item-spacer"></span> fn <a href="#method.by_ref" class="fn">by_ref</a>(&amp;mut self) -&gt; <a class="struct" href="combinator/struct.ByRef.html" title="struct winnow::combinator::ByRef">ByRef</a>&lt;'_, Self&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a></span> { ... }
<span class="item-spacer"></span> fn <a href="#method.value" class="fn">value</a>&lt;O2&gt;(self, val: O2) -&gt; <a class="struct" href="combinator/struct.Value.html" title="struct winnow::combinator::Value">Value</a>&lt;Self, I, O, O2, E&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
O2: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a></span> { ... }
<span class="item-spacer"></span> fn <a href="#method.default_value" class="fn">default_value</a>&lt;O2&gt;(self) -&gt; <a class="struct" href="combinator/struct.DefaultValue.html" title="struct winnow::combinator::DefaultValue">DefaultValue</a>&lt;Self, I, O, O2, E&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
O2: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/default/trait.Default.html" title="trait core::default::Default">Default</a></span> { ... }
<span class="item-spacer"></span> fn <a href="#method.void" class="fn">void</a>(self) -&gt; <a class="struct" href="combinator/struct.Void.html" title="struct winnow::combinator::Void">Void</a>&lt;Self, I, O, E&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a></span> { ... }
<span class="item-spacer"></span> fn <a href="#method.output_into" class="fn">output_into</a>&lt;O2&gt;(self) -&gt; <a class="struct" href="combinator/struct.OutputInto.html" title="struct winnow::combinator::OutputInto">OutputInto</a>&lt;Self, I, O, O2, E&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
O: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;O2&gt;</span> { ... }
<span class="item-spacer"></span> fn <a href="#method.recognize" class="fn">recognize</a>(self) -&gt; <a class="struct" href="combinator/struct.Recognize.html" title="struct winnow::combinator::Recognize">Recognize</a>&lt;Self, I, O, E&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a></span> { ... }
<span class="item-spacer"></span> fn <a href="#method.with_recognized" class="fn">with_recognized</a>(self) -&gt; <a class="struct" href="combinator/struct.WithRecognized.html" title="struct winnow::combinator::WithRecognized">WithRecognized</a>&lt;Self, I, O, E&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a></span> { ... }
<span class="item-spacer"></span> fn <a href="#method.span" class="fn">span</a>(self) -&gt; <a class="struct" href="combinator/struct.Span.html" title="struct winnow::combinator::Span">Span</a>&lt;Self, I, O, E&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a> + <a class="trait" href="stream/trait.Location.html" title="trait winnow::stream::Location">Location</a></span> { ... }
<span class="item-spacer"></span> fn <a href="#method.with_span" class="fn">with_span</a>(self) -&gt; <a class="struct" href="combinator/struct.WithSpan.html" title="struct winnow::combinator::WithSpan">WithSpan</a>&lt;Self, I, O, E&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a> + <a class="trait" href="stream/trait.Location.html" title="trait winnow::stream::Location">Location</a></span> { ... }
<span class="item-spacer"></span> fn <a href="#method.map" class="fn">map</a>&lt;G, O2&gt;(self, map: G) -&gt; <a class="struct" href="combinator/struct.Map.html" title="struct winnow::combinator::Map">Map</a>&lt;Self, G, I, O, O2, E&gt;
<span class="where">where G: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(O) -&gt; O2,
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a></span> { ... }
<span class="item-spacer"></span> fn <a href="#method.try_map" class="fn">try_map</a>&lt;G, O2, E2&gt;(self, map: G) -&gt; <a class="struct" href="combinator/struct.TryMap.html" title="struct winnow::combinator::TryMap">TryMap</a>&lt;Self, G, I, O, O2, E, E2&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
G: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(O) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;O2, E2&gt;,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,
E: <a class="trait" href="error/trait.FromExternalError.html" title="trait winnow::error::FromExternalError">FromExternalError</a>&lt;I, E2&gt;</span> { ... }
<span class="item-spacer"></span> fn <a href="#method.verify_map" class="fn">verify_map</a>&lt;G, O2&gt;(self, map: G) -&gt; <a class="struct" href="combinator/struct.VerifyMap.html" title="struct winnow::combinator::VerifyMap">VerifyMap</a>&lt;Self, G, I, O, O2, E&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
G: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(O) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a>&lt;O2&gt;,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,
E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;</span> { ... }
<span class="item-spacer"></span> fn <a href="#method.flat_map" class="fn">flat_map</a>&lt;G, H, O2&gt;(self, map: G) -&gt; <a class="struct" href="combinator/struct.FlatMap.html" title="struct winnow::combinator::FlatMap">FlatMap</a>&lt;Self, G, H, I, O, O2, E&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
G: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(O) -&gt; H,
H: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;</span> { ... }
<span class="item-spacer"></span> fn <a href="#method.and_then" class="fn">and_then</a>&lt;G, O2&gt;(self, inner: G) -&gt; <a class="struct" href="combinator/struct.AndThen.html" title="struct winnow::combinator::AndThen">AndThen</a>&lt;Self, G, I, O, O2, E&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
G: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;O, O2, E&gt;,
O: <a class="trait" href="stream/trait.StreamIsPartial.html" title="trait winnow::stream::StreamIsPartial">StreamIsPartial</a>,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a></span> { ... }
<span class="item-spacer"></span> fn <a href="#method.parse_to" class="fn">parse_to</a>&lt;O2&gt;(self) -&gt; <a class="struct" href="combinator/struct.ParseTo.html" title="struct winnow::combinator::ParseTo">ParseTo</a>&lt;Self, I, O, O2, E&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,
O: <a class="trait" href="stream/trait.ParseSlice.html" title="trait winnow::stream::ParseSlice">ParseSlice</a>&lt;O2&gt;,
E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;</span> { ... }
<span class="item-spacer"></span> fn <a href="#method.verify" class="fn">verify</a>&lt;G, O2&gt;(self, filter: G) -&gt; <a class="struct" href="combinator/struct.Verify.html" title="struct winnow::combinator::Verify">Verify</a>&lt;Self, G, I, O, O2, E&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
G: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;O2</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.bool.html">bool</a>,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,
O: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a>&lt;O2&gt;,
O2: ?<a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;</span> { ... }
<span class="item-spacer"></span> fn <a href="#method.context" class="fn">context</a>&lt;C&gt;(self, context: C) -&gt; <a class="struct" href="combinator/struct.Context.html" title="struct winnow::combinator::Context">Context</a>&lt;Self, I, O, E, C&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,
E: <a class="trait" href="error/trait.AddContext.html" title="trait winnow::error::AddContext">AddContext</a>&lt;I, C&gt;,
C: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a></span> { ... }
<span class="item-spacer"></span> fn <a href="#method.complete_err" class="fn">complete_err</a>(self) -&gt; <a class="struct" href="combinator/struct.CompleteErr.html" title="struct winnow::combinator::CompleteErr">CompleteErr</a>&lt;Self&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a></span> { ... }
<span class="item-spacer"></span> fn <a href="#method.err_into" class="fn">err_into</a>&lt;E2&gt;(self) -&gt; <a class="struct" href="combinator/struct.ErrInto.html" title="struct winnow::combinator::ErrInto">ErrInto</a>&lt;Self, I, O, E, E2&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
E: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;E2&gt;</span> { ... }
</details>}</code></pre><details class="toggle top-doc" open><summary class="hideme"><span>Expand description</span></summary><div class="docblock"><p>Core trait for parsing</p>
<p>The simplest way to implement a <code>Parser</code> is with a function</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>winnow::prelude::<span class="kw-2">*</span>;
<span class="kw">fn </span>empty(input: <span class="kw-2">&amp;mut &amp;</span>str) -&gt; PResult&lt;()&gt; {
<span class="kw">let </span>output = ();
<span class="prelude-val">Ok</span>(output)
}
<span class="kw">let </span>(input, output) = empty.parse_peek(<span class="string">"Hello"</span>).unwrap();
<span class="macro">assert_eq!</span>(input, <span class="string">"Hello"</span>); <span class="comment">// We didn't consume any input</span></code></pre></div>
<p>which can be made stateful by returning a function</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>winnow::prelude::<span class="kw-2">*</span>;
<span class="kw">fn </span>empty&lt;O: Clone&gt;(output: O) -&gt; <span class="kw">impl </span>FnMut(<span class="kw-2">&amp;mut &amp;</span>str) -&gt; PResult&lt;O&gt; {
<span class="kw">move </span>|input: <span class="kw-2">&amp;mut &amp;</span>str| {
<span class="kw">let </span>output = output.clone();
<span class="prelude-val">Ok</span>(output)
}
}
<span class="kw">let </span>(input, output) = empty(<span class="string">"World"</span>).parse_peek(<span class="string">"Hello"</span>).unwrap();
<span class="macro">assert_eq!</span>(input, <span class="string">"Hello"</span>); <span class="comment">// We didn't consume any input
</span><span class="macro">assert_eq!</span>(output, <span class="string">"World"</span>);</code></pre></div>
<p>Additionally, some basic types implement <code>Parser</code> as well, including</p>
<ul>
<li><code>u8</code> and <code>char</code>, see <a href="token/fn.one_of.html" title="fn winnow::token::one_of"><code>winnow::token::one_of</code></a></li>
<li><code>&amp;[u8]</code> and <code>&amp;str</code>, see <a href="token/fn.literal.html" title="fn winnow::token::literal"><code>winnow::token::literal</code></a></li>
</ul>
</div></details><h2 id="required-methods" class="section-header">Required Methods<a href="#required-methods" class="anchor">§</a></h2><div class="methods"><details class="toggle method-toggle" open><summary><section id="tymethod.parse_next" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#80">source</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(&amp;mut self, input: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;O, E&gt;</h4></section></summary><div class="docblock"><p>Take tokens from the <a href="stream/trait.Stream.html" title="trait winnow::stream::Stream"><code>Stream</code></a>, turning it into the output</p>
<p>This includes advancing the <a href="stream/trait.Stream.html" title="trait winnow::stream::Stream"><code>Stream</code></a> to the next location.</p>
<p>On error, <code>input</code> will be left pointing at the error location.</p>
</div></details></div><h2 id="provided-methods" class="section-header">Provided Methods<a href="#provided-methods" class="anchor">§</a></h2><div class="methods"><details class="toggle method-toggle" open><summary><section id="method.parse" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#49-73">source</a><h4 class="code-header">fn <a href="#method.parse" class="fn">parse</a>(&amp;mut self, input: I) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;O, <a class="struct" href="error/struct.ParseError.html" title="struct winnow::error::ParseError">ParseError</a>&lt;I, E&gt;&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a> + <a class="trait" href="stream/trait.StreamIsPartial.html" title="trait winnow::stream::StreamIsPartial">StreamIsPartial</a> + <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>,
E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;,</div></h4></section></summary><div class="docblock"><p>Parse all of <code>input</code>, generating <code>O</code> from it</p>
</div></details><details class="toggle method-toggle" open><summary><section id="method.parse_peek" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#86-91">source</a><h4 class="code-header">fn <a href="#method.parse_peek" class="fn">parse_peek</a>(&amp;mut self, input: I) -&gt; <a class="type" href="error/type.IResult.html" title="type winnow::error::IResult">IResult</a>&lt;I, O, E&gt;</h4></section></summary><div class="docblock"><p>Take tokens from the <a href="stream/trait.Stream.html" title="trait winnow::stream::Stream"><code>Stream</code></a>, turning it into the output</p>
<p>This includes advancing the <a href="stream/trait.Stream.html" title="trait winnow::stream::Stream"><code>Stream</code></a> to the next location.</p>
</div></details><details class="toggle method-toggle" open><summary><section id="method.by_ref" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#137-142">source</a><h4 class="code-header">fn <a href="#method.by_ref" class="fn">by_ref</a>(&amp;mut self) -&gt; <a class="struct" href="combinator/struct.ByRef.html" title="struct winnow::combinator::ByRef">ByRef</a>&lt;'_, Self&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h4></section></summary><div class="docblock"><p>Treat <code>&amp;mut Self</code> as a parser</p>
<p>This helps when needing to move a <code>Parser</code> when all you have is a <code>&amp;mut Parser</code>.</p>
<h5 id="example"><a href="#example">Example</a></h5>
<p>Because parsers are <code>FnMut</code>, they can be called multiple times. This prevents moving <code>f</code>
into <a href="binary/fn.length_take.html" title="fn winnow::binary::length_take"><code>length_take</code></a> and <code>g</code> into
<a href="trait.Parser.html#method.complete_err" title="method winnow::Parser::complete_err"><code>Parser::complete_err</code></a>:</p>
<div class="example-wrap compile_fail"><a href="#" class="tooltip" title="This example deliberately fails to compile">ⓘ</a><pre class="rust rust-example-rendered"><code><span class="kw">pub fn </span>length_value&lt;<span class="lifetime">'i</span>, O, E: ParserError&lt;<span class="kw-2">&amp;</span><span class="lifetime">'i </span>[u8]&gt;&gt;(
<span class="kw-2">mut </span>f: <span class="kw">impl </span>Parser&lt;<span class="kw-2">&amp;</span><span class="lifetime">'i </span>[u8], usize, E&gt;,
<span class="kw-2">mut </span>g: <span class="kw">impl </span>Parser&lt;<span class="kw-2">&amp;</span><span class="lifetime">'i </span>[u8], O, E&gt;
) -&gt; <span class="kw">impl </span>Parser&lt;<span class="kw-2">&amp;</span><span class="lifetime">'i </span>[u8], O, E&gt; {
<span class="kw">move </span>|i: <span class="kw-2">&amp;mut &amp;</span><span class="lifetime">'i </span>[u8]| {
<span class="kw">let </span><span class="kw-2">mut </span>data = length_take(f).parse_next(i)<span class="question-mark">?</span>;
<span class="kw">let </span>o = g.complete_err().parse_next(<span class="kw-2">&amp;mut </span>data)<span class="question-mark">?</span>;
<span class="prelude-val">Ok</span>(o)
}
}</code></pre></div>
<p>By adding <code>by_ref</code>, we can make this work:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">pub fn </span>length_value&lt;<span class="lifetime">'i</span>, O, E: ParserError&lt;<span class="kw-2">&amp;</span><span class="lifetime">'i </span>[u8]&gt;&gt;(
<span class="kw-2">mut </span>f: <span class="kw">impl </span>Parser&lt;<span class="kw-2">&amp;</span><span class="lifetime">'i </span>[u8], usize, E&gt;,
<span class="kw-2">mut </span>g: <span class="kw">impl </span>Parser&lt;<span class="kw-2">&amp;</span><span class="lifetime">'i </span>[u8], O, E&gt;
) -&gt; <span class="kw">impl </span>Parser&lt;<span class="kw-2">&amp;</span><span class="lifetime">'i </span>[u8], O, E&gt; {
<span class="kw">move </span>|i: <span class="kw-2">&amp;mut &amp;</span><span class="lifetime">'i </span>[u8]| {
<span class="kw">let </span><span class="kw-2">mut </span>data = length_take(f.by_ref()).parse_next(i)<span class="question-mark">?</span>;
<span class="kw">let </span>o = g.by_ref().complete_err().parse_next(<span class="kw-2">&amp;mut </span>data)<span class="question-mark">?</span>;
<span class="prelude-val">Ok</span>(o)
}
}</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.value" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#161-167">source</a><h4 class="code-header">fn <a href="#method.value" class="fn">value</a>&lt;O2&gt;(self, val: O2) -&gt; <a class="struct" href="combinator/struct.Value.html" title="struct winnow::combinator::Value">Value</a>&lt;Self, I, O, O2, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
O2: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>,</div></h4></section></summary><div class="docblock"><p>Produce the provided value</p>
<h5 id="example-1"><a href="#example-1">Example</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>winnow::ascii::alpha1;
<span class="kw">let </span><span class="kw-2">mut </span>parser = alpha1.value(<span class="number">1234</span>);
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"abcd"</span>), <span class="prelude-val">Ok</span>((<span class="string">""</span>, <span class="number">1234</span>)));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"123abcd;"</span>), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">"123abcd;"</span>, ErrorKind::Slice))));</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.default_value" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#185-191">source</a><h4 class="code-header">fn <a href="#method.default_value" class="fn">default_value</a>&lt;O2&gt;(self) -&gt; <a class="struct" href="combinator/struct.DefaultValue.html" title="struct winnow::combinator::DefaultValue">DefaultValue</a>&lt;Self, I, O, O2, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
O2: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/default/trait.Default.html" title="trait core::default::Default">Default</a>,</div></h4></section></summary><div class="docblock"><p>Produce a type’s default value</p>
<h5 id="example-2"><a href="#example-2">Example</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>winnow::ascii::alpha1;
<span class="kw">let </span><span class="kw-2">mut </span>parser = alpha1.default_value::&lt;u32&gt;();
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"abcd"</span>), <span class="prelude-val">Ok</span>((<span class="string">""</span>, <span class="number">0</span>)));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"123abcd;"</span>), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">"123abcd;"</span>, ErrorKind::Slice))));</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.void" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#209-214">source</a><h4 class="code-header">fn <a href="#method.void" class="fn">void</a>(self) -&gt; <a class="struct" href="combinator/struct.Void.html" title="struct winnow::combinator::Void">Void</a>&lt;Self, I, O, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h4></section></summary><div class="docblock"><p>Discards the output of the <code>Parser</code></p>
<h5 id="example-3"><a href="#example-3">Example</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>winnow::ascii::alpha1;
<span class="kw">let </span><span class="kw-2">mut </span>parser = alpha1.void();
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"abcd"</span>), <span class="prelude-val">Ok</span>((<span class="string">""</span>, ())));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"123abcd;"</span>), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">"123abcd;"</span>, ErrorKind::Slice))));</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.output_into" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#238-244">source</a><h4 class="code-header">fn <a href="#method.output_into" class="fn">output_into</a>&lt;O2&gt;(self) -&gt; <a class="struct" href="combinator/struct.OutputInto.html" title="struct winnow::combinator::OutputInto">OutputInto</a>&lt;Self, I, O, O2, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
O: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;O2&gt;,</div></h4></section></summary><div class="docblock"><p>Convert the parser’s output to another type using <a href="https://doc.rust-lang.org/1.76.0/core/convert/trait.From.html" title="trait core::convert::From"><code>std::convert::From</code></a></p>
<h5 id="example-4"><a href="#example-4">Example</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>winnow::ascii::alpha1;
<span class="kw">fn </span>parser1&lt;<span class="lifetime">'s</span>&gt;(i: <span class="kw-2">&amp;mut &amp;</span><span class="lifetime">'s </span>str) -&gt; PResult&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>str, InputError&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>str&gt;&gt; {
alpha1(i)
}
<span class="kw">let </span><span class="kw-2">mut </span>parser2 = parser1.output_into();
<span class="comment">// the parser converts the &amp;str output of the child parser into a Vec&lt;u8&gt;
</span><span class="kw">let </span>bytes: IResult&lt;<span class="kw-2">&amp;</span>str, Vec&lt;u8&gt;&gt; = parser2.parse_peek(<span class="string">"abcd"</span>);
<span class="macro">assert_eq!</span>(bytes, <span class="prelude-val">Ok</span>((<span class="string">""</span>, <span class="macro">vec!</span>[<span class="number">97</span>, <span class="number">98</span>, <span class="number">99</span>, <span class="number">100</span>])));</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.recognize" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#264-270">source</a><h4 class="code-header">fn <a href="#method.recognize" class="fn">recognize</a>(self) -&gt; <a class="struct" href="combinator/struct.Recognize.html" title="struct winnow::combinator::Recognize">Recognize</a>&lt;Self, I, O, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,</div></h4></section></summary><div class="docblock"><p>Produce the consumed input as produced value.</p>
<h5 id="example-5"><a href="#example-5">Example</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>winnow::ascii::{alpha1};
<span class="kw">use </span>winnow::combinator::separated_pair;
<span class="kw">let </span><span class="kw-2">mut </span>parser = separated_pair(alpha1, <span class="string">','</span>, alpha1).recognize();
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"abcd,efgh"</span>), <span class="prelude-val">Ok</span>((<span class="string">""</span>, <span class="string">"abcd,efgh"</span>)));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"abcd;"</span>),<span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">";"</span>, ErrorKind::Tag))));</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.with_recognized" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#310-316">source</a><h4 class="code-header">fn <a href="#method.with_recognized" class="fn">with_recognized</a>(self) -&gt; <a class="struct" href="combinator/struct.WithRecognized.html" title="struct winnow::combinator::WithRecognized">WithRecognized</a>&lt;Self, I, O, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,</div></h4></section></summary><div class="docblock"><p>Produce the consumed input with the output</p>
<p>Functions similarly to <a href="trait.Parser.html#method.recognize" title="method winnow::Parser::recognize">recognize</a> except it
returns the parser output as well.</p>
<p>This can be useful especially in cases where the output is not the same type
as the input, or the input is a user defined type.</p>
<p>Returned tuple is of the format <code>(produced output, consumed input)</code>.</p>
<h5 id="example-6"><a href="#example-6">Example</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>winnow::ascii::{alpha1};
<span class="kw">use </span>winnow::token::literal;
<span class="kw">use </span>winnow::combinator::separated_pair;
<span class="kw">fn </span>inner_parser&lt;<span class="lifetime">'s</span>&gt;(input: <span class="kw-2">&amp;mut &amp;</span><span class="lifetime">'s </span>str) -&gt; PResult&lt;bool, InputError&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>str&gt;&gt; {
<span class="string">"1234"</span>.value(<span class="bool-val">true</span>).parse_next(input)
}
<span class="kw">let </span><span class="kw-2">mut </span>consumed_parser = separated_pair(alpha1, <span class="string">','</span>, alpha1).value(<span class="bool-val">true</span>).with_recognized();
<span class="macro">assert_eq!</span>(consumed_parser.parse_peek(<span class="string">"abcd,efgh1"</span>), <span class="prelude-val">Ok</span>((<span class="string">"1"</span>, (<span class="bool-val">true</span>, <span class="string">"abcd,efgh"</span>))));
<span class="macro">assert_eq!</span>(consumed_parser.parse_peek(<span class="string">"abcd;"</span>),<span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">";"</span>, ErrorKind::Tag))));
<span class="comment">// the second output (representing the consumed input)
// should be the same as that of the `recognize` parser.
</span><span class="kw">let </span><span class="kw-2">mut </span>recognize_parser = inner_parser.recognize();
<span class="kw">let </span><span class="kw-2">mut </span>consumed_parser = inner_parser.with_recognized().map(|(output, consumed)| consumed);
<span class="macro">assert_eq!</span>(recognize_parser.parse_peek(<span class="string">"1234"</span>), consumed_parser.parse_peek(<span class="string">"1234"</span>));
<span class="macro">assert_eq!</span>(recognize_parser.parse_peek(<span class="string">"abcd"</span>), consumed_parser.parse_peek(<span class="string">"abcd"</span>));</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.span" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#335-341">source</a><h4 class="code-header">fn <a href="#method.span" class="fn">span</a>(self) -&gt; <a class="struct" href="combinator/struct.Span.html" title="struct winnow::combinator::Span">Span</a>&lt;Self, I, O, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a> + <a class="trait" href="stream/trait.Location.html" title="trait winnow::stream::Location">Location</a>,</div></h4></section></summary><div class="docblock"><p>Produce the location of the consumed input as produced value.</p>
<h5 id="example-7"><a href="#example-7">Example</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>winnow::stream::Located;
<span class="kw">use </span>winnow::ascii::alpha1;
<span class="kw">use </span>winnow::combinator::separated_pair;
<span class="kw">let </span><span class="kw-2">mut </span>parser = separated_pair(alpha1.span(), <span class="string">','</span>, alpha1.span());
<span class="macro">assert_eq!</span>(parser.parse(Located::new(<span class="string">"abcd,efgh"</span>)), <span class="prelude-val">Ok</span>((<span class="number">0</span>..<span class="number">4</span>, <span class="number">5</span>..<span class="number">9</span>)));
<span class="macro">assert_eq!</span>(parser.parse_peek(Located::new(<span class="string">"abcd;"</span>)),<span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(Located::new(<span class="string">"abcd;"</span>).peek_slice(<span class="number">4</span>).<span class="number">0</span>, ErrorKind::Tag))));</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.with_span" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#384-390">source</a><h4 class="code-header">fn <a href="#method.with_span" class="fn">with_span</a>(self) -&gt; <a class="struct" href="combinator/struct.WithSpan.html" title="struct winnow::combinator::WithSpan">WithSpan</a>&lt;Self, I, O, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a> + <a class="trait" href="stream/trait.Location.html" title="trait winnow::stream::Location">Location</a>,</div></h4></section></summary><div class="docblock"><p>Produce the location of consumed input with the output</p>
<p>Functions similarly to <a href="trait.Parser.html#method.span" title="method winnow::Parser::span"><code>Parser::span</code></a> except it
returns the parser output as well.</p>
<p>This can be useful especially in cases where the output is not the same type
as the input, or the input is a user defined type.</p>
<p>Returned tuple is of the format <code>(produced output, consumed input)</code>.</p>
<h5 id="example-8"><a href="#example-8">Example</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>winnow::stream::Located;
<span class="kw">use </span>winnow::ascii::alpha1;
<span class="kw">use </span>winnow::token::literal;
<span class="kw">use </span>winnow::combinator::separated_pair;
<span class="kw">fn </span>inner_parser&lt;<span class="lifetime">'s</span>&gt;(input: <span class="kw-2">&amp;mut </span>Located&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>str&gt;) -&gt; PResult&lt;bool, InputError&lt;Located&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>str&gt;&gt;&gt; {
<span class="string">"1234"</span>.value(<span class="bool-val">true</span>).parse_next(input)
}
<span class="kw">let </span><span class="kw-2">mut </span>consumed_parser = separated_pair(alpha1.value(<span class="number">1</span>).with_span(), <span class="string">','</span>, alpha1.value(<span class="number">2</span>).with_span());
<span class="macro">assert_eq!</span>(consumed_parser.parse(Located::new(<span class="string">"abcd,efgh"</span>)), <span class="prelude-val">Ok</span>(((<span class="number">1</span>, <span class="number">0</span>..<span class="number">4</span>), (<span class="number">2</span>, <span class="number">5</span>..<span class="number">9</span>))));
<span class="macro">assert_eq!</span>(consumed_parser.parse_peek(Located::new(<span class="string">"abcd;"</span>)),<span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(Located::new(<span class="string">"abcd;"</span>).peek_slice(<span class="number">4</span>).<span class="number">0</span>, ErrorKind::Tag))));
<span class="comment">// the second output (representing the consumed input)
// should be the same as that of the `span` parser.
</span><span class="kw">let </span><span class="kw-2">mut </span>recognize_parser = inner_parser.span();
<span class="kw">let </span><span class="kw-2">mut </span>consumed_parser = inner_parser.with_span().map(|(output, consumed)| consumed);
<span class="macro">assert_eq!</span>(recognize_parser.parse_peek(Located::new(<span class="string">"1234"</span>)), consumed_parser.parse_peek(Located::new(<span class="string">"1234"</span>)));
<span class="macro">assert_eq!</span>(recognize_parser.parse_peek(Located::new(<span class="string">"abcd"</span>)), consumed_parser.parse_peek(Located::new(<span class="string">"abcd"</span>)));</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.map" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#411-417">source</a><h4 class="code-header">fn <a href="#method.map" class="fn">map</a>&lt;G, O2&gt;(self, map: G) -&gt; <a class="struct" href="combinator/struct.Map.html" title="struct winnow::combinator::Map">Map</a>&lt;Self, G, I, O, O2, E&gt;<div class="where">where
G: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(O) -&gt; O2,
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h4></section></summary><div class="docblock"><p>Maps a function over the output of a parser</p>
<h5 id="example-9"><a href="#example-9">Example</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>winnow::{error::ErrMode,error::ErrorKind, error::InputError, Parser};
<span class="kw">use </span>winnow::ascii::digit1;
<span class="kw">let </span><span class="kw-2">mut </span>parser = digit1.map(|s: <span class="kw-2">&amp;</span>str| s.len());
<span class="comment">// the parser will count how many characters were returned by digit1
</span><span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"123456"</span>), <span class="prelude-val">Ok</span>((<span class="string">""</span>, <span class="number">6</span>)));
<span class="comment">// this will fail if digit1 fails
</span><span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"abc"</span>), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">"abc"</span>, ErrorKind::Slice))));</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.try_map" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#441-449">source</a><h4 class="code-header">fn <a href="#method.try_map" class="fn">try_map</a>&lt;G, O2, E2&gt;(self, map: G) -&gt; <a class="struct" href="combinator/struct.TryMap.html" title="struct winnow::combinator::TryMap">TryMap</a>&lt;Self, G, I, O, O2, E, E2&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
G: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(O) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;O2, E2&gt;,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,
E: <a class="trait" href="error/trait.FromExternalError.html" title="trait winnow::error::FromExternalError">FromExternalError</a>&lt;I, E2&gt;,</div></h4></section></summary><div class="docblock"><p>Applies a function returning a <code>Result</code> over the output of a parser.</p>
<h5 id="example-10"><a href="#example-10">Example</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>winnow::ascii::digit1;
<span class="kw">let </span><span class="kw-2">mut </span>parse = digit1.try_map(|s: <span class="kw-2">&amp;</span>str| s.parse::&lt;u8&gt;());
<span class="comment">// the parser will convert the result of digit1 to a number
</span><span class="macro">assert_eq!</span>(parse.parse_peek(<span class="string">"123"</span>), <span class="prelude-val">Ok</span>((<span class="string">""</span>, <span class="number">123</span>)));
<span class="comment">// this will fail if digit1 fails
</span><span class="macro">assert_eq!</span>(parse.parse_peek(<span class="string">"abc"</span>), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">"abc"</span>, ErrorKind::Slice))));
<span class="comment">// this will fail if the mapped function fails (a `u8` is too small to hold `123456`)
</span><span class="macro">assert_eq!</span>(parse.parse_peek(<span class="string">"123456"</span>), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">"123456"</span>, ErrorKind::Verify))));</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.verify_map" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#476-484">source</a><h4 class="code-header">fn <a href="#method.verify_map" class="fn">verify_map</a>&lt;G, O2&gt;(self, map: G) -&gt; <a class="struct" href="combinator/struct.VerifyMap.html" title="struct winnow::combinator::VerifyMap">VerifyMap</a>&lt;Self, G, I, O, O2, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
G: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(O) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a>&lt;O2&gt;,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,
E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;,</div></h4></section></summary><div class="docblock"><p>Apply both <a href="trait.Parser.html#method.verify" title="method winnow::Parser::verify"><code>Parser::verify</code></a> and <a href="trait.Parser.html#method.map" title="method winnow::Parser::map"><code>Parser::map</code></a>.</p>
<h5 id="example-11"><a href="#example-11">Example</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>winnow::ascii::digit1;
<span class="kw">let </span><span class="kw-2">mut </span>parse = digit1.verify_map(|s: <span class="kw-2">&amp;</span>str| s.parse::&lt;u8&gt;().ok());
<span class="comment">// the parser will convert the result of digit1 to a number
</span><span class="macro">assert_eq!</span>(parse.parse_peek(<span class="string">"123"</span>), <span class="prelude-val">Ok</span>((<span class="string">""</span>, <span class="number">123</span>)));
<span class="comment">// this will fail if digit1 fails
</span><span class="macro">assert_eq!</span>(parse.parse_peek(<span class="string">"abc"</span>), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">"abc"</span>, ErrorKind::Slice))));
<span class="comment">// this will fail if the mapped function fails (a `u8` is too small to hold `123456`)
</span><span class="macro">assert_eq!</span>(parse.parse_peek(<span class="string">"123456"</span>), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">"123456"</span>, ErrorKind::Verify))));</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.flat_map" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#519-526">source</a><h4 class="code-header">fn <a href="#method.flat_map" class="fn">flat_map</a>&lt;G, H, O2&gt;(self, map: G) -&gt; <a class="struct" href="combinator/struct.FlatMap.html" title="struct winnow::combinator::FlatMap">FlatMap</a>&lt;Self, G, H, I, O, O2, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
G: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(O) -&gt; H,
H: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,</div></h4></section></summary><div class="docblock"><p>Creates a parser from the output of this one</p>
<h5 id="example-12"><a href="#example-12">Example</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>winnow::token::take;
<span class="kw">use </span>winnow::binary::u8;
<span class="kw">fn </span>length_take&lt;<span class="lifetime">'s</span>&gt;(input: <span class="kw-2">&amp;mut &amp;</span><span class="lifetime">'s </span>[u8]) -&gt; PResult&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>[u8], InputError&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>[u8]&gt;&gt; {
u8.flat_map(take).parse_next(input)
}
<span class="macro">assert_eq!</span>(length_take.parse_peek(<span class="kw-2">&amp;</span>[<span class="number">2</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>][..]), <span class="prelude-val">Ok</span>((<span class="kw-2">&amp;</span>[<span class="number">2</span>][..], <span class="kw-2">&amp;</span>[<span class="number">0</span>, <span class="number">1</span>][..])));
<span class="macro">assert_eq!</span>(length_take.parse_peek(<span class="kw-2">&amp;</span>[<span class="number">4</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>][..]), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="kw-2">&amp;</span>[<span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>][..], ErrorKind::Slice))));</code></pre></div>
<p>which is the same as</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>winnow::token::take;
<span class="kw">use </span>winnow::binary::u8;
<span class="kw">fn </span>length_take&lt;<span class="lifetime">'s</span>&gt;(input: <span class="kw-2">&amp;mut &amp;</span><span class="lifetime">'s </span>[u8]) -&gt; PResult&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>[u8], InputError&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>[u8]&gt;&gt; {
<span class="kw">let </span>length = u8.parse_next(input)<span class="question-mark">?</span>;
<span class="kw">let </span>data = take(length).parse_next(input)<span class="question-mark">?</span>;
<span class="prelude-val">Ok</span>(data)
}
<span class="macro">assert_eq!</span>(length_take.parse_peek(<span class="kw-2">&amp;</span>[<span class="number">2</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>][..]), <span class="prelude-val">Ok</span>((<span class="kw-2">&amp;</span>[<span class="number">2</span>][..], <span class="kw-2">&amp;</span>[<span class="number">0</span>, <span class="number">1</span>][..])));
<span class="macro">assert_eq!</span>(length_take.parse_peek(<span class="kw-2">&amp;</span>[<span class="number">4</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>][..]), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="kw-2">&amp;</span>[<span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>][..], ErrorKind::Slice))));</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.and_then" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#546-554">source</a><h4 class="code-header">fn <a href="#method.and_then" class="fn">and_then</a>&lt;G, O2&gt;(self, inner: G) -&gt; <a class="struct" href="combinator/struct.AndThen.html" title="struct winnow::combinator::AndThen">AndThen</a>&lt;Self, G, I, O, O2, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
G: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;O, O2, E&gt;,
O: <a class="trait" href="stream/trait.StreamIsPartial.html" title="trait winnow::stream::StreamIsPartial">StreamIsPartial</a>,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,</div></h4></section></summary><div class="docblock"><p>Applies a second parser over the output of the first one</p>
<h5 id="example-13"><a href="#example-13">Example</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>winnow::ascii::digit1;
<span class="kw">use </span>winnow::token::take;
<span class="kw">let </span><span class="kw-2">mut </span>digits = take(<span class="number">5u8</span>).and_then(digit1);
<span class="macro">assert_eq!</span>(digits.parse_peek(<span class="string">"12345"</span>), <span class="prelude-val">Ok</span>((<span class="string">""</span>, <span class="string">"12345"</span>)));
<span class="macro">assert_eq!</span>(digits.parse_peek(<span class="string">"123ab"</span>), <span class="prelude-val">Ok</span>((<span class="string">""</span>, <span class="string">"123"</span>)));
<span class="macro">assert_eq!</span>(digits.parse_peek(<span class="string">"123"</span>), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">"123"</span>, ErrorKind::Slice))));</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.parse_to" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#577-585">source</a><h4 class="code-header">fn <a href="#method.parse_to" class="fn">parse_to</a>&lt;O2&gt;(self) -&gt; <a class="struct" href="combinator/struct.ParseTo.html" title="struct winnow::combinator::ParseTo">ParseTo</a>&lt;Self, I, O, O2, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,
O: <a class="trait" href="stream/trait.ParseSlice.html" title="trait winnow::stream::ParseSlice">ParseSlice</a>&lt;O2&gt;,
E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;,</div></h4></section></summary><div class="docblock"><p>Apply <a href="https://doc.rust-lang.org/1.76.0/core/str/traits/trait.FromStr.html" title="trait core::str::traits::FromStr"><code>std::str::FromStr</code></a> to the output of the parser</p>
<h5 id="example-14"><a href="#example-14">Example</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>winnow::{error::ErrMode,error::ErrorKind, error::InputError, Parser};
<span class="kw">use </span>winnow::ascii::digit1;
<span class="kw">fn </span>parser&lt;<span class="lifetime">'s</span>&gt;(input: <span class="kw-2">&amp;mut &amp;</span><span class="lifetime">'s </span>str) -&gt; PResult&lt;u64, InputError&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>str&gt;&gt; {
digit1.parse_to().parse_next(input)
}
<span class="comment">// the parser will count how many characters were returned by digit1
</span><span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"123456"</span>), <span class="prelude-val">Ok</span>((<span class="string">""</span>, <span class="number">123456</span>)));
<span class="comment">// this will fail if digit1 fails
</span><span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"abc"</span>), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">"abc"</span>, ErrorKind::Slice))));</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.verify" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#609-619">source</a><h4 class="code-header">fn <a href="#method.verify" class="fn">verify</a>&lt;G, O2&gt;(self, filter: G) -&gt; <a class="struct" href="combinator/struct.Verify.html" title="struct winnow::combinator::Verify">Verify</a>&lt;Self, G, I, O, O2, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
G: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;O2</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.bool.html">bool</a>,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,
O: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a>&lt;O2&gt;,
O2: ?<a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;,</div></h4></section></summary><div class="docblock"><p>Returns the output of the child parser if it satisfies a verification function.</p>
<p>The verification function takes as argument a reference to the output of the
parser.</p>
<h5 id="example-15"><a href="#example-15">Example</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code>
<span class="kw">let </span><span class="kw-2">mut </span>parser = alpha1.verify(|s: <span class="kw-2">&amp;</span>str| s.len() == <span class="number">4</span>);
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"abcd"</span>), <span class="prelude-val">Ok</span>((<span class="string">""</span>, <span class="string">"abcd"</span>)));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"abcde"</span>), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">"abcde"</span>, ErrorKind::Verify))));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"123abcd;"</span>),<span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">"123abcd;"</span>, ErrorKind::Slice))));</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.context" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#627-635">source</a><h4 class="code-header">fn <a href="#method.context" class="fn">context</a>&lt;C&gt;(self, context: C) -&gt; <a class="struct" href="combinator/struct.Context.html" title="struct winnow::combinator::Context">Context</a>&lt;Self, I, O, E, C&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,
E: <a class="trait" href="error/trait.AddContext.html" title="trait winnow::error::AddContext">AddContext</a>&lt;I, C&gt;,
C: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a>,</div></h4></section></summary><div class="docblock"><p>If parsing fails, add context to the error</p>
<p>This is used mainly to add user friendly information
to errors when backtracking through a parse tree.</p>
</div></details><details class="toggle method-toggle" open><summary><section id="method.complete_err" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#653-658">source</a><h4 class="code-header">fn <a href="#method.complete_err" class="fn">complete_err</a>(self) -&gt; <a class="struct" href="combinator/struct.CompleteErr.html" title="struct winnow::combinator::CompleteErr">CompleteErr</a>&lt;Self&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h4></section></summary><div class="docblock"><p>Transforms <a href="error/enum.ErrMode.html#variant.Incomplete" title="variant winnow::error::ErrMode::Incomplete"><code>Incomplete</code></a> into <a href="error/enum.ErrMode.html#variant.Backtrack" title="variant winnow::error::ErrMode::Backtrack"><code>Backtrack</code></a></p>
<h5 id="example-16"><a href="#example-16">Example</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code>
<span class="kw">let </span><span class="kw-2">mut </span>parser = take(<span class="number">5u8</span>).complete_err();
<span class="macro">assert_eq!</span>(parser.parse_peek(Partial::new(<span class="string">"abcdefg"</span>)), <span class="prelude-val">Ok</span>((Partial::new(<span class="string">"fg"</span>), <span class="string">"abcde"</span>)));
<span class="macro">assert_eq!</span>(parser.parse_peek(Partial::new(<span class="string">"abcd"</span>)), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(Partial::new(<span class="string">"abcd"</span>), ErrorKind::Complete))));</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.err_into" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#662-668">source</a><h4 class="code-header">fn <a href="#method.err_into" class="fn">err_into</a>&lt;E2&gt;(self) -&gt; <a class="struct" href="combinator/struct.ErrInto.html" title="struct winnow::combinator::ErrInto">ErrInto</a>&lt;Self, I, O, E, E2&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
E: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;E2&gt;,</div></h4></section></summary><div class="docblock"><p>Convert the parser’s error to another type using <a href="https://doc.rust-lang.org/1.76.0/core/convert/trait.From.html" title="trait core::convert::From"><code>std::convert::From</code></a></p>
</div></details></div><h2 id="trait-implementations" class="section-header">Trait Implementations<a href="#trait-implementations" class="anchor">§</a></h2><div id="trait-implementations-list"><details class="toggle implementors-toggle" open><summary><section id="impl-Parser%3CI,+O,+E%3E-for-Box%3Cdyn+Parser%3CI,+O,+E%3E%3E" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1091-1096">source</a><a href="#impl-Parser%3CI,+O,+E%3E-for-Box%3Cdyn+Parser%3CI,+O,+E%3E%3E" class="anchor">§</a><h3 class="code-header">impl&lt;'a, I, O, E&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt; for <a class="struct" href="https://doc.rust-lang.org/1.76.0/alloc/boxed/struct.Box.html" title="struct alloc::boxed::Box">Box</a>&lt;dyn <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt; + 'a&gt;</h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.parse_next" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1093-1095">source</a><a href="#method.parse_next" class="anchor">§</a><h4 class="code-header">fn <a href="trait.Parser.html#tymethod.parse_next" class="fn">parse_next</a>(&amp;mut self, i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;O, E&gt;</h4></section></summary><div class='docblock'>Take tokens from the <a href="stream/trait.Stream.html" title="trait winnow::stream::Stream"><code>Stream</code></a>, turning it into the output <a href="trait.Parser.html#tymethod.parse_next">Read more</a></div></details><details class="toggle method-toggle" open><summary><section id="method.parse_peek-1" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#86-91">source</a><a href="#method.parse_peek-1" class="anchor">§</a><h4 class="code-header">fn <a href="trait.Parser.html#method.parse_peek" class="fn">parse_peek</a>(&amp;mut self, input: I) -&gt; <a class="type" href="error/type.IResult.html" title="type winnow::error::IResult">IResult</a>&lt;I, O, E&gt;</h4></section></summary><div class='docblock'>Take tokens from the <a href="stream/trait.Stream.html" title="trait winnow::stream::Stream"><code>Stream</code></a>, turning it into the output <a href="trait.Parser.html#method.parse_peek">Read more</a></div></details><details class="toggle method-toggle" open><summary><section id="method.by_ref-1" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#137-142">source</a><a href="#method.by_ref-1" class="anchor">§</a><h4 class="code-header">fn <a href="trait.Parser.html#method.by_ref" class="fn">by_ref</a>(&amp;mut self) -&gt; <a class="struct" href="combinator/struct.ByRef.html" title="struct winnow::combinator::ByRef">ByRef</a>&lt;'_, Self&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h4></section></summary><div class='docblock'>Treat <code>&amp;mut Self</code> as a parser <a href="trait.Parser.html#method.by_ref">Read more</a></div></details><details class="toggle method-toggle" open><summary><section id="method.value-1" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#161-167">source</a><a href="#method.value-1" class="anchor">§</a><h4 class="code-header">fn <a href="trait.Parser.html#method.value" class="fn">value</a>&lt;O2&gt;(self, val: O2) -&gt; <a class="struct" href="combinator/struct.Value.html" title="struct winnow::combinator::Value">Value</a>&lt;Self, I, O, O2, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
O2: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>,</div></h4></section></summary><div class='docblock'>Produce the provided value <a href="trait.Parser.html#method.value">Read more</a></div></details><details class="toggle method-toggle" open><summary><section id="method.default_value-1" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#185-191">source</a><a href="#method.default_value-1" class="anchor">§</a><h4 class="code-header">fn <a href="trait.Parser.html#method.default_value" class="fn">default_value</a>&lt;O2&gt;(self) -&gt; <a class="struct" href="combinator/struct.DefaultValue.html" title="struct winnow::combinator::DefaultValue">DefaultValue</a>&lt;Self, I, O, O2, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
O2: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/default/trait.Default.html" title="trait core::default::Default">Default</a>,</div></h4></section></summary><div class='docblock'>Produce a type’s default value <a href="trait.Parser.html#method.default_value">Read more</a></div></details><details class="toggle method-toggle" open><summary><section id="method.void-1" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#209-214">source</a><a href="#method.void-1" class="anchor">§</a><h4 class="code-header">fn <a href="trait.Parser.html#method.void" class="fn">void</a>(self) -&gt; <a class="struct" href="combinator/struct.Void.html" title="struct winnow::combinator::Void">Void</a>&lt;Self, I, O, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h4></section></summary><div class='docblock'>Discards the output of the <code>Parser</code> <a href="trait.Parser.html#method.void">Read more</a></div></details><details class="toggle method-toggle" open><summary><section id="method.output_into-1" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#238-244">source</a><a href="#method.output_into-1" class="anchor">§</a><h4 class="code-header">fn <a href="trait.Parser.html#method.output_into" class="fn">output_into</a>&lt;O2&gt;(self) -&gt; <a class="struct" href="combinator/struct.OutputInto.html" title="struct winnow::combinator::OutputInto">OutputInto</a>&lt;Self, I, O, O2, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
O: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;O2&gt;,</div></h4></section></summary><div class='docblock'>Convert the parser’s output to another type using <a href="https://doc.rust-lang.org/1.76.0/core/convert/trait.From.html" title="trait core::convert::From"><code>std::convert::From</code></a> <a href="trait.Parser.html#method.output_into">Read more</a></div></details><details class="toggle method-toggle" open><summary><section id="method.map-1" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#411-417">source</a><a href="#method.map-1" class="anchor">§</a><h4 class="code-header">fn <a href="trait.Parser.html#method.map" class="fn">map</a>&lt;G, O2&gt;(self, map: G) -&gt; <a class="struct" href="combinator/struct.Map.html" title="struct winnow::combinator::Map">Map</a>&lt;Self, G, I, O, O2, E&gt;<div class="where">where
G: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(O) -&gt; O2,
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h4></section></summary><div class='docblock'>Maps a function over the output of a parser <a href="trait.Parser.html#method.map">Read more</a></div></details><details class="toggle method-toggle" open><summary><section id="method.flat_map-1" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#519-526">source</a><a href="#method.flat_map-1" class="anchor">§</a><h4 class="code-header">fn <a href="trait.Parser.html#method.flat_map" class="fn">flat_map</a>&lt;G, H, O2&gt;(self, map: G) -&gt; <a class="struct" href="combinator/struct.FlatMap.html" title="struct winnow::combinator::FlatMap">FlatMap</a>&lt;Self, G, H, I, O, O2, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
G: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(O) -&gt; H,
H: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,</div></h4></section></summary><div class='docblock'>Creates a parser from the output of this one <a href="trait.Parser.html#method.flat_map">Read more</a></div></details><details class="toggle method-toggle" open><summary><section id="method.complete_err-1" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#653-658">source</a><a href="#method.complete_err-1" class="anchor">§</a><h4 class="code-header">fn <a href="trait.Parser.html#method.complete_err" class="fn">complete_err</a>(self) -&gt; <a class="struct" href="combinator/struct.CompleteErr.html" title="struct winnow::combinator::CompleteErr">CompleteErr</a>&lt;Self&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h4></section></summary><div class='docblock'>Transforms <a href="error/enum.ErrMode.html#variant.Incomplete" title="variant winnow::error::ErrMode::Incomplete"><code>Incomplete</code></a> into <a href="error/enum.ErrMode.html#variant.Backtrack" title="variant winnow::error::ErrMode::Backtrack"><code>Backtrack</code></a> <a href="trait.Parser.html#method.complete_err">Read more</a></div></details><details class="toggle method-toggle" open><summary><section id="method.err_into-1" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#662-668">source</a><a href="#method.err_into-1" class="anchor">§</a><h4 class="code-header">fn <a href="trait.Parser.html#method.err_into" class="fn">err_into</a>&lt;E2&gt;(self) -&gt; <a class="struct" href="combinator/struct.ErrInto.html" title="struct winnow::combinator::ErrInto">ErrInto</a>&lt;Self, I, O, E, E2&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
E: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;E2&gt;,</div></h4></section></summary><div class='docblock'>Convert the parser’s error to another type using <a href="https://doc.rust-lang.org/1.76.0/core/convert/trait.From.html" title="trait core::convert::From"><code>std::convert::From</code></a></div></details></div></details></div><h2 id="foreign-impls" class="section-header">Implementations on Foreign Types<a href="#foreign-impls" class="anchor">§</a></h2><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+O,+E%3E-for-Box%3Cdyn+Parser%3CI,+O,+E%3E%3E-1" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1091-1096">source</a><a href="#impl-Parser%3CI,+O,+E%3E-for-Box%3Cdyn+Parser%3CI,+O,+E%3E%3E-1" class="anchor">§</a><h3 class="code-header">impl&lt;'a, I, O, E&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt; for <a class="struct" href="https://doc.rust-lang.org/1.76.0/alloc/boxed/struct.Box.html" title="struct alloc::boxed::Box">Box</a>&lt;dyn <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt; + 'a&gt;</h3></section></summary><div class="impl-items"><section id="method.parse_next-1" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1093-1095">source</a><a href="#method.parse_next-1" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(&amp;mut self, i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;O, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+%3CI+as+Stream%3E::Slice,+E%3E-for-%26str" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#916-925">source</a><a href="#impl-Parser%3CI,+%3CI+as+Stream%3E::Slice,+E%3E-for-%26str" class="anchor">§</a><h3 class="code-header">impl&lt;'s, I, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, &lt;I as <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>&gt;::<a class="associatedtype" href="stream/trait.Stream.html#associatedtype.Slice" title="type winnow::stream::Stream::Slice">Slice</a>, E&gt; for &amp;'s <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.str.html">str</a><div class="where">where
I: <a class="trait" href="stream/trait.Compare.html" title="trait winnow::stream::Compare">Compare</a>&lt;&amp;'s <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.str.html">str</a>&gt; + <a class="trait" href="stream/trait.StreamIsPartial.html" title="trait winnow::stream::StreamIsPartial">StreamIsPartial</a> + <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,</div></h3></section></summary><div class="docblock"><p>This is a shortcut for <a href="token/fn.literal.html" title="fn winnow::token::literal"><code>literal</code></a>.</p>
<h4 id="example-17"><a href="#example-17">Example</a></h4>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code>
<span class="kw">fn </span>parser&lt;<span class="lifetime">'s</span>&gt;(s: <span class="kw-2">&amp;mut &amp;</span><span class="lifetime">'s </span>str) -&gt; PResult&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>str, InputError&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>str&gt;&gt; {
alt((<span class="string">"Hello"</span>, take(<span class="number">5usize</span>))).parse_next(s)
}
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"Hello, World!"</span>), <span class="prelude-val">Ok</span>((<span class="string">", World!"</span>, <span class="string">"Hello"</span>)));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"Something"</span>), <span class="prelude-val">Ok</span>((<span class="string">"hing"</span>, <span class="string">"Somet"</span>)));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"Some"</span>), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">"Some"</span>, ErrorKind::Slice))));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">""</span>), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">""</span>, ErrorKind::Slice))));</code></pre></div>
</div><div class="impl-items"><section id="method.parse_next-2" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#922-924">source</a><a href="#method.parse_next-2" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(&amp;mut self, i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;&lt;I as <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>&gt;::<a class="associatedtype" href="stream/trait.Stream.html#associatedtype.Slice" title="type winnow::stream::Stream::Slice">Slice</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+%3CI+as+Stream%3E::Slice,+E%3E-for-%26%5Bu8%5D" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#793-802">source</a><a href="#impl-Parser%3CI,+%3CI+as+Stream%3E::Slice,+E%3E-for-%26%5Bu8%5D" class="anchor">§</a><h3 class="code-header">impl&lt;'s, I, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, &lt;I as <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>&gt;::<a class="associatedtype" href="stream/trait.Stream.html#associatedtype.Slice" title="type winnow::stream::Stream::Slice">Slice</a>, E&gt; for &amp;'s [<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.u8.html">u8</a>]<div class="where">where
I: <a class="trait" href="stream/trait.Compare.html" title="trait winnow::stream::Compare">Compare</a>&lt;&amp;'s [<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.u8.html">u8</a>]&gt; + <a class="trait" href="stream/trait.StreamIsPartial.html" title="trait winnow::stream::StreamIsPartial">StreamIsPartial</a> + <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,</div></h3></section></summary><div class="docblock"><p>This is a shortcut for <a href="token/fn.literal.html" title="fn winnow::token::literal"><code>literal</code></a>.</p>
<h4 id="example-18"><a href="#example-18">Example</a></h4>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code>
<span class="kw">fn </span>parser&lt;<span class="lifetime">'s</span>&gt;(s: <span class="kw-2">&amp;mut &amp;</span><span class="lifetime">'s </span>[u8]) -&gt; PResult&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>[u8], InputError&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>[u8]&gt;&gt; {
alt((<span class="kw-2">&amp;</span><span class="string">"Hello"</span>[..], take(<span class="number">5usize</span>))).parse_next(s)
}
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b"Hello, World!"</span>[..]), <span class="prelude-val">Ok</span>((<span class="kw-2">&amp;</span><span class="string">b", World!"</span>[..], <span class="kw-2">&amp;</span><span class="string">b"Hello"</span>[..])));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b"Something"</span>[..]), <span class="prelude-val">Ok</span>((<span class="kw-2">&amp;</span><span class="string">b"hing"</span>[..], <span class="kw-2">&amp;</span><span class="string">b"Somet"</span>[..])));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b"Some"</span>[..]), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="kw-2">&amp;</span><span class="string">b"Some"</span>[..], ErrorKind::Slice))));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b""</span>[..]), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="kw-2">&amp;</span><span class="string">b""</span>[..], ErrorKind::Slice))));</code></pre></div>
</div><div class="impl-items"><section id="method.parse_next-3" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#799-801">source</a><a href="#method.parse_next-3" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(&amp;mut self, i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;&lt;I as <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>&gt;::<a class="associatedtype" href="stream/trait.Stream.html#associatedtype.Slice" title="type winnow::stream::Stream::Slice">Slice</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+%3CI+as+Stream%3E::Slice,+E%3E-for-%26%5Bu8;+N%5D" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#854-863">source</a><a href="#impl-Parser%3CI,+%3CI+as+Stream%3E::Slice,+E%3E-for-%26%5Bu8;+N%5D" class="anchor">§</a><h3 class="code-header">impl&lt;'s, I, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, const N: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.usize.html">usize</a>&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, &lt;I as <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>&gt;::<a class="associatedtype" href="stream/trait.Stream.html#associatedtype.Slice" title="type winnow::stream::Stream::Slice">Slice</a>, E&gt; for &amp;'s [<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.u8.html">u8</a>; <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.array.html">N</a>]<div class="where">where
I: <a class="trait" href="stream/trait.Compare.html" title="trait winnow::stream::Compare">Compare</a>&lt;&amp;'s [<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.u8.html">u8</a>; <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.array.html">N</a>]&gt; + <a class="trait" href="stream/trait.StreamIsPartial.html" title="trait winnow::stream::StreamIsPartial">StreamIsPartial</a> + <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,</div></h3></section></summary><div class="docblock"><p>This is a shortcut for <a href="token/fn.literal.html" title="fn winnow::token::literal"><code>literal</code></a>.</p>
<h4 id="example-19"><a href="#example-19">Example</a></h4>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code>
<span class="kw">fn </span>parser&lt;<span class="lifetime">'s</span>&gt;(s: <span class="kw-2">&amp;mut &amp;</span><span class="lifetime">'s </span>[u8]) -&gt; PResult&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>[u8], InputError&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>[u8]&gt;&gt; {
alt((<span class="string">b"Hello"</span>, take(<span class="number">5usize</span>))).parse_next(s)
}
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b"Hello, World!"</span>[..]), <span class="prelude-val">Ok</span>((<span class="kw-2">&amp;</span><span class="string">b", World!"</span>[..], <span class="kw-2">&amp;</span><span class="string">b"Hello"</span>[..])));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b"Something"</span>[..]), <span class="prelude-val">Ok</span>((<span class="kw-2">&amp;</span><span class="string">b"hing"</span>[..], <span class="kw-2">&amp;</span><span class="string">b"Somet"</span>[..])));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b"Some"</span>[..]), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="kw-2">&amp;</span><span class="string">b"Some"</span>[..], ErrorKind::Slice))));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b""</span>[..]), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="kw-2">&amp;</span><span class="string">b""</span>[..], ErrorKind::Slice))));</code></pre></div>
</div><div class="impl-items"><section id="method.parse_next-4" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#860-862">source</a><a href="#method.parse_next-4" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(&amp;mut self, i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;&lt;I as <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>&gt;::<a class="associatedtype" href="stream/trait.Stream.html#associatedtype.Slice" title="type winnow::stream::Stream::Slice">Slice</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+char,+E%3E-for-char" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#762-773">source</a><a href="#impl-Parser%3CI,+char,+E%3E-for-char" class="anchor">§</a><h3 class="code-header">impl&lt;I, E&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.char.html">char</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.char.html">char</a><div class="where">where
I: <a class="trait" href="stream/trait.StreamIsPartial.html" title="trait winnow::stream::StreamIsPartial">StreamIsPartial</a> + <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a> + <a class="trait" href="stream/trait.Compare.html" title="trait winnow::stream::Compare">Compare</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.char.html">char</a>&gt;,
E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;,</div></h3></section></summary><div class="docblock"><p>This is a shortcut for <a href="token/fn.one_of.html" title="fn winnow::token::one_of"><code>one_of</code></a>.</p>
<h4 id="example-20"><a href="#example-20">Example</a></h4>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">fn </span>parser&lt;<span class="lifetime">'s</span>&gt;(i: <span class="kw-2">&amp;mut &amp;</span><span class="lifetime">'s </span>str) -&gt; PResult&lt;char, InputError&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>str&gt;&gt; {
<span class="string">'a'</span>.parse_next(i)
}
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"abc"</span>), <span class="prelude-val">Ok</span>((<span class="string">"bc"</span>, <span class="string">'a'</span>)));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">" abc"</span>), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">" abc"</span>, ErrorKind::Tag))));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"bc"</span>), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">"bc"</span>, ErrorKind::Tag))));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">""</span>), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">""</span>, ErrorKind::Tag))));</code></pre></div>
</div><div class="impl-items"><section id="method.parse_next-5" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#770-772">source</a><a href="#method.parse_next-5" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(&amp;mut self, i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.char.html">char</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+u8,+E%3E-for-u8" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#734-745">source</a><a href="#impl-Parser%3CI,+u8,+E%3E-for-u8" class="anchor">§</a><h3 class="code-header">impl&lt;I, E&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.u8.html">u8</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.u8.html">u8</a><div class="where">where
I: <a class="trait" href="stream/trait.StreamIsPartial.html" title="trait winnow::stream::StreamIsPartial">StreamIsPartial</a> + <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a> + <a class="trait" href="stream/trait.Compare.html" title="trait winnow::stream::Compare">Compare</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.u8.html">u8</a>&gt;,
E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;,</div></h3></section></summary><div class="docblock"><p>This is a shortcut for <a href="token/fn.one_of.html" title="fn winnow::token::one_of"><code>one_of</code></a>.</p>
<h4 id="example-21"><a href="#example-21">Example</a></h4>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">fn </span>parser&lt;<span class="lifetime">'s</span>&gt;(i: <span class="kw-2">&amp;mut &amp;</span><span class="lifetime">'s </span>[u8]) -&gt; PResult&lt;u8, InputError&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>[u8]&gt;&gt; {
<span class="string">b'a'</span>.parse_next(i)
}
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b"abc"</span>[..]), <span class="prelude-val">Ok</span>((<span class="kw-2">&amp;</span><span class="string">b"bc"</span>[..], <span class="string">b'a'</span>)));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b" abc"</span>[..]), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="kw-2">&amp;</span><span class="string">b" abc"</span>[..], ErrorKind::Tag))));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b"bc"</span>[..]), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="kw-2">&amp;</span><span class="string">b"bc"</span>[..], ErrorKind::Tag))));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b""</span>[..]), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="kw-2">&amp;</span><span class="string">b""</span>[..], ErrorKind::Tag))));</code></pre></div>
</div><div class="impl-items"><section id="method.parse_next-6" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#742-744">source</a><a href="#method.parse_next-6" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(&amp;mut self, i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.u8.html">u8</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(),+E%3E-for-()" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#959-964">source</a><a href="#impl-Parser%3CI,+(),+E%3E-for-()" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.unit.html">()</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.unit.html">()</a></h3></section></summary><div class="impl-items"><section id="method.parse_next-7" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#961-963">source</a><a href="#method.parse_next-7" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(&amp;mut self, _i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.unit.html">()</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,),+E%3E-for-(P1,)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,),+E%3E-for-(P1,)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1,)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1,)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-8" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-8" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(&amp;mut self, i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1,)</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,+O2),+E%3E-for-(P1,+P2)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,+O2),+E%3E-for-(P1,+P2)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, O2, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1, P2&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1, P2)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,
P2: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-9" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-9" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(&amp;mut self, i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2)</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,+O2,+O3),+E%3E-for-(P1,+P2,+P3)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,+O2,+O3),+E%3E-for-(P1,+P2,+P3)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, O2, O3, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1, P2, P3&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1, P2, P3)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,
P2: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,
P3: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O3, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-10" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-10" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(&amp;mut self, i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3)</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,+O2,+O3,+O4),+E%3E-for-(P1,+P2,+P3,+P4)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4),+E%3E-for-(P1,+P2,+P3,+P4)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, O2, O3, O4, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1, P2, P3, P4&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1, P2, P3, P4)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,
P2: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,
P3: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O3, E&gt;,
P4: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O4, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-11" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-11" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(&amp;mut self, i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4)</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5),+E%3E-for-(P1,+P2,+P3,+P4,+P5)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5),+E%3E-for-(P1,+P2,+P3,+P4,+P5)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, O2, O3, O4, O5, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1, P2, P3, P4, P5&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1, P2, P3, P4, P5)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,
P2: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,
P3: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O3, E&gt;,
P4: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O4, E&gt;,
P5: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O5, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-12" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-12" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(&amp;mut self, i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5)</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, O2, O3, O4, O5, O6, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1, P2, P3, P4, P5, P6&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1, P2, P3, P4, P5, P6)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,
P2: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,
P3: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O3, E&gt;,
P4: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O4, E&gt;,
P5: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O5, E&gt;,
P6: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O6, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-13" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-13" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(&amp;mut self, i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6)</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, O2, O3, O4, O5, O6, O7, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1, P2, P3, P4, P5, P6, P7&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1, P2, P3, P4, P5, P6, P7)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,
P2: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,
P3: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O3, E&gt;,
P4: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O4, E&gt;,
P5: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O5, E&gt;,
P6: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O6, E&gt;,
P7: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O7, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-14" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-14" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(&amp;mut self, i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7)</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, O2, O3, O4, O5, O6, O7, O8, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1, P2, P3, P4, P5, P6, P7, P8&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1, P2, P3, P4, P5, P6, P7, P8)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,
P2: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,
P3: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O3, E&gt;,
P4: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O4, E&gt;,
P5: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O5, E&gt;,
P6: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O6, E&gt;,
P7: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O7, E&gt;,
P8: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O8, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-15" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-15" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(
&amp;mut self,
i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>
) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8)</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, O2, O3, O4, O5, O6, O7, O8, O9, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1, P2, P3, P4, P5, P6, P7, P8, P9&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1, P2, P3, P4, P5, P6, P7, P8, P9)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,
P2: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,
P3: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O3, E&gt;,
P4: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O4, E&gt;,
P5: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O5, E&gt;,
P6: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O6, E&gt;,
P7: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O7, E&gt;,
P8: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O8, E&gt;,
P9: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O9, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-16" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-16" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(
&amp;mut self,
i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>
) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9)</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,
P2: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,
P3: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O3, E&gt;,
P4: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O4, E&gt;,
P5: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O5, E&gt;,
P6: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O6, E&gt;,
P7: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O7, E&gt;,
P8: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O8, E&gt;,
P9: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O9, E&gt;,
P10: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O10, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-17" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-17" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(
&amp;mut self,
i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>
) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10)</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,
P2: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,
P3: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O3, E&gt;,
P4: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O4, E&gt;,
P5: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O5, E&gt;,
P6: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O6, E&gt;,
P7: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O7, E&gt;,
P8: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O8, E&gt;,
P9: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O9, E&gt;,
P10: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O10, E&gt;,
P11: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O11, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-18" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-18" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(
&amp;mut self,
i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>
) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11)</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,
P2: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,
P3: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O3, E&gt;,
P4: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O4, E&gt;,
P5: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O5, E&gt;,
P6: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O6, E&gt;,
P7: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O7, E&gt;,
P8: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O8, E&gt;,
P9: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O9, E&gt;,
P10: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O10, E&gt;,
P11: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O11, E&gt;,
P12: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O12, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-19" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-19" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(
&amp;mut self,
i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>
) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12)</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,
P2: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,
P3: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O3, E&gt;,
P4: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O4, E&gt;,
P5: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O5, E&gt;,
P6: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O6, E&gt;,
P7: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O7, E&gt;,
P8: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O8, E&gt;,
P9: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O9, E&gt;,
P10: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O10, E&gt;,
P11: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O11, E&gt;,
P12: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O12, E&gt;,
P13: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O13, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-20" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-20" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(
&amp;mut self,
i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>
) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13)</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,
P2: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,
P3: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O3, E&gt;,
P4: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O4, E&gt;,
P5: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O5, E&gt;,
P6: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O6, E&gt;,
P7: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O7, E&gt;,
P8: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O8, E&gt;,
P9: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O9, E&gt;,
P10: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O10, E&gt;,
P11: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O11, E&gt;,
P12: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O12, E&gt;,
P13: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O13, E&gt;,
P14: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O14, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-21" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-21" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(
&amp;mut self,
i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>
) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14)</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,
P2: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,
P3: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O3, E&gt;,
P4: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O4, E&gt;,
P5: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O5, E&gt;,
P6: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O6, E&gt;,
P7: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O7, E&gt;,
P8: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O8, E&gt;,
P9: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O9, E&gt;,
P10: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O10, E&gt;,
P11: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O11, E&gt;,
P12: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O12, E&gt;,
P13: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O13, E&gt;,
P14: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O14, E&gt;,
P15: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O15, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-22" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-22" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(
&amp;mut self,
i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>
) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15)</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15,+O16),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15,+P16)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15,+O16),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15,+P16)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,
P2: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,
P3: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O3, E&gt;,
P4: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O4, E&gt;,
P5: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O5, E&gt;,
P6: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O6, E&gt;,
P7: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O7, E&gt;,
P8: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O8, E&gt;,
P9: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O9, E&gt;,
P10: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O10, E&gt;,
P11: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O11, E&gt;,
P12: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O12, E&gt;,
P13: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O13, E&gt;,
P14: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O14, E&gt;,
P15: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O15, E&gt;,
P16: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O16, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-23" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-23" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(
&amp;mut self,
i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>
) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16)</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15,+O16,+O17),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15,+P16,+P17)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15,+O16,+O17),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15,+P16,+P17)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,
P2: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,
P3: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O3, E&gt;,
P4: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O4, E&gt;,
P5: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O5, E&gt;,
P6: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O6, E&gt;,
P7: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O7, E&gt;,
P8: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O8, E&gt;,
P9: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O9, E&gt;,
P10: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O10, E&gt;,
P11: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O11, E&gt;,
P12: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O12, E&gt;,
P13: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O13, E&gt;,
P14: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O14, E&gt;,
P15: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O15, E&gt;,
P16: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O16, E&gt;,
P17: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O17, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-24" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-24" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(
&amp;mut self,
i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>
) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17)</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15,+O16,+O17,+O18),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15,+P16,+P17,+P18)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15,+O16,+O17,+O18),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15,+P16,+P17,+P18)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,
P2: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,
P3: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O3, E&gt;,
P4: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O4, E&gt;,
P5: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O5, E&gt;,
P6: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O6, E&gt;,
P7: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O7, E&gt;,
P8: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O8, E&gt;,
P9: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O9, E&gt;,
P10: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O10, E&gt;,
P11: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O11, E&gt;,
P12: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O12, E&gt;,
P13: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O13, E&gt;,
P14: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O14, E&gt;,
P15: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O15, E&gt;,
P16: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O16, E&gt;,
P17: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O17, E&gt;,
P18: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O18, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-25" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-25" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(
&amp;mut self,
i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>
) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18)</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15,+O16,+O17,+O18,+O19),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15,+P16,+P17,+P18,+P19)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15,+O16,+O17,+O18,+O19),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15,+P16,+P17,+P18,+P19)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,
P2: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,
P3: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O3, E&gt;,
P4: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O4, E&gt;,
P5: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O5, E&gt;,
P6: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O6, E&gt;,
P7: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O7, E&gt;,
P8: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O8, E&gt;,
P9: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O9, E&gt;,
P10: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O10, E&gt;,
P11: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O11, E&gt;,
P12: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O12, E&gt;,
P13: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O13, E&gt;,
P14: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O14, E&gt;,
P15: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O15, E&gt;,
P16: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O16, E&gt;,
P17: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O17, E&gt;,
P18: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O18, E&gt;,
P19: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O19, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-26" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-26" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(
&amp;mut self,
i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>
) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19)</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15,+O16,+O17,+O18,+O19,+O20),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15,+P16,+P17,+P18,+P19,+P20)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15,+O16,+O17,+O18,+O19,+O20),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15,+P16,+P17,+P18,+P19,+P20)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,
P2: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,
P3: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O3, E&gt;,
P4: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O4, E&gt;,
P5: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O5, E&gt;,
P6: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O6, E&gt;,
P7: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O7, E&gt;,
P8: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O8, E&gt;,
P9: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O9, E&gt;,
P10: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O10, E&gt;,
P11: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O11, E&gt;,
P12: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O12, E&gt;,
P13: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O13, E&gt;,
P14: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O14, E&gt;,
P15: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O15, E&gt;,
P16: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O16, E&gt;,
P17: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O17, E&gt;,
P18: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O18, E&gt;,
P19: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O19, E&gt;,
P20: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O20, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-27" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-27" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(
&amp;mut self,
i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>
) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20)</a>, E&gt;</h4></section></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15,+O16,+O17,+O18,+O19,+O20,+O21),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15,+P16,+P17,+P18,+P19,+P20,+P21)" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#impl-Parser%3CI,+(O1,+O2,+O3,+O4,+O5,+O6,+O7,+O8,+O9,+O10,+O11,+O12,+O13,+O14,+O15,+O16,+O17,+O18,+O19,+O20,+O21),+E%3E-for-(P1,+P2,+P3,+P4,+P5,+P6,+P7,+P8,+P9,+P10,+P11,+P12,+P13,+P14,+P15,+P16,+P17,+P18,+P19,+P20,+P21)" class="anchor">§</a><h3 class="code-header">impl&lt;I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20, O21, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20, O21)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21)</a><div class="where">where
P1: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O1, E&gt;,
P2: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,
P3: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O3, E&gt;,
P4: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O4, E&gt;,
P5: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O5, E&gt;,
P6: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O6, E&gt;,
P7: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O7, E&gt;,
P8: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O8, E&gt;,
P9: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O9, E&gt;,
P10: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O10, E&gt;,
P11: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O11, E&gt;,
P12: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O12, E&gt;,
P13: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O13, E&gt;,
P14: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O14, E&gt;,
P15: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O15, E&gt;,
P16: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O16, E&gt;,
P17: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O17, E&gt;,
P18: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O18, E&gt;,
P19: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O19, E&gt;,
P20: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O20, E&gt;,
P21: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O21, E&gt;,</div></h3></section></summary><div class="impl-items"><section id="method.parse_next-28" class="method trait-impl"><a class="src rightside" href="../src/winnow/parser.rs.html#1063-1085">source</a><a href="#method.parse_next-28" class="anchor">§</a><h4 class="code-header">fn <a href="#tymethod.parse_next" class="fn">parse_next</a>(
&amp;mut self,
i: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>
) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20, O21)</a>, E&gt;</h4></section></div></details><h2 id="implementors" class="section-header">Implementors<a href="#implementors" class="anchor">§</a></h2><div id="implementors-list"><section id="impl-Parser%3CI,+O,+E%3E-for-F" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#708-717">source</a><a href="#impl-Parser%3CI,+O,+E%3E-for-F" class="anchor">§</a><h3 class="code-header">impl&lt;'a, I, O, E, F&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt; for F<div class="where">where
F: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;mut I</a>) -&gt; <a class="type" href="error/type.PResult.html" title="type winnow::error::PResult">PResult</a>&lt;O, E&gt; + 'a,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,</div></h3></section><section id="impl-Parser%3CI,+O,+E%3E-for-ByRef%3C'p,+P%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#28-36">source</a><a href="#impl-Parser%3CI,+O,+E%3E-for-ByRef%3C'p,+P%3E" class="anchor">§</a><h3 class="code-header">impl&lt;'p, I, O, E, P&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt; for <a class="struct" href="combinator/struct.ByRef.html" title="struct winnow::combinator::ByRef">ByRef</a>&lt;'p, P&gt;<div class="where">where
P: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt;,</div></h3></section><section id="impl-Parser%3CI,+%3CI+as+Stream%3E::Slice,+E%3E-for-Caseless%3C%26str%3E" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#948-957">source</a><a href="#impl-Parser%3CI,+%3CI+as+Stream%3E::Slice,+E%3E-for-Caseless%3C%26str%3E" class="anchor">§</a><h3 class="code-header">impl&lt;'s, I, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, &lt;I as <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>&gt;::<a class="associatedtype" href="stream/trait.Stream.html#associatedtype.Slice" title="type winnow::stream::Stream::Slice">Slice</a>, E&gt; for <a class="struct" href="ascii/struct.Caseless.html" title="struct winnow::ascii::Caseless">Caseless</a>&lt;&amp;'s <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.str.html">str</a>&gt;<div class="where">where
I: <a class="trait" href="stream/trait.Compare.html" title="trait winnow::stream::Compare">Compare</a>&lt;<a class="struct" href="ascii/struct.Caseless.html" title="struct winnow::ascii::Caseless">Caseless</a>&lt;&amp;'s <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.str.html">str</a>&gt;&gt; + <a class="trait" href="stream/trait.StreamIsPartial.html" title="trait winnow::stream::StreamIsPartial">StreamIsPartial</a> + <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,</div></h3></section><div class="docblock"><p>This is a shortcut for <a href="token/fn.literal.html" title="fn winnow::token::literal"><code>literal</code></a>.</p>
<h4 id="example-22"><a href="#example-22">Example</a></h4>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code>
<span class="kw">fn </span>parser&lt;<span class="lifetime">'s</span>&gt;(s: <span class="kw-2">&amp;mut &amp;</span><span class="lifetime">'s </span>str) -&gt; PResult&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>str, InputError&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>str&gt;&gt; {
alt((Caseless(<span class="string">"hello"</span>), take(<span class="number">5usize</span>))).parse_next(s)
}
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"Hello, World!"</span>), <span class="prelude-val">Ok</span>((<span class="string">", World!"</span>, <span class="string">"Hello"</span>)));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"hello, World!"</span>), <span class="prelude-val">Ok</span>((<span class="string">", World!"</span>, <span class="string">"hello"</span>)));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"HeLlo, World!"</span>), <span class="prelude-val">Ok</span>((<span class="string">", World!"</span>, <span class="string">"HeLlo"</span>)));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"Something"</span>), <span class="prelude-val">Ok</span>((<span class="string">"hing"</span>, <span class="string">"Somet"</span>)));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">"Some"</span>), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">"Some"</span>, ErrorKind::Slice))));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="string">""</span>), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="string">""</span>, ErrorKind::Slice))));</code></pre></div>
</div><section id="impl-Parser%3CI,+%3CI+as+Stream%3E::Slice,+E%3E-for-Caseless%3C%26%5Bu8%5D%3E" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#825-834">source</a><a href="#impl-Parser%3CI,+%3CI+as+Stream%3E::Slice,+E%3E-for-Caseless%3C%26%5Bu8%5D%3E" class="anchor">§</a><h3 class="code-header">impl&lt;'s, I, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, &lt;I as <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>&gt;::<a class="associatedtype" href="stream/trait.Stream.html#associatedtype.Slice" title="type winnow::stream::Stream::Slice">Slice</a>, E&gt; for <a class="struct" href="ascii/struct.Caseless.html" title="struct winnow::ascii::Caseless">Caseless</a>&lt;&amp;'s [<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.u8.html">u8</a>]&gt;<div class="where">where
I: <a class="trait" href="stream/trait.Compare.html" title="trait winnow::stream::Compare">Compare</a>&lt;<a class="struct" href="ascii/struct.Caseless.html" title="struct winnow::ascii::Caseless">Caseless</a>&lt;&amp;'s [<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.u8.html">u8</a>]&gt;&gt; + <a class="trait" href="stream/trait.StreamIsPartial.html" title="trait winnow::stream::StreamIsPartial">StreamIsPartial</a> + <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,</div></h3></section><div class="docblock"><p>This is a shortcut for <a href="token/fn.literal.html" title="fn winnow::token::literal"><code>literal</code></a>.</p>
<h4 id="example-23"><a href="#example-23">Example</a></h4>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>winnow::ascii::Caseless;
<span class="kw">fn </span>parser&lt;<span class="lifetime">'s</span>&gt;(s: <span class="kw-2">&amp;mut &amp;</span><span class="lifetime">'s </span>[u8]) -&gt; PResult&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>[u8], InputError&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>[u8]&gt;&gt; {
alt((Caseless(<span class="kw-2">&amp;</span><span class="string">"hello"</span>[..]), take(<span class="number">5usize</span>))).parse_next(s)
}
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b"Hello, World!"</span>[..]), <span class="prelude-val">Ok</span>((<span class="kw-2">&amp;</span><span class="string">b", World!"</span>[..], <span class="kw-2">&amp;</span><span class="string">b"Hello"</span>[..])));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b"hello, World!"</span>[..]), <span class="prelude-val">Ok</span>((<span class="kw-2">&amp;</span><span class="string">b", World!"</span>[..], <span class="kw-2">&amp;</span><span class="string">b"hello"</span>[..])));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b"HeLlo, World!"</span>[..]), <span class="prelude-val">Ok</span>((<span class="kw-2">&amp;</span><span class="string">b", World!"</span>[..], <span class="kw-2">&amp;</span><span class="string">b"HeLlo"</span>[..])));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b"Something"</span>[..]), <span class="prelude-val">Ok</span>((<span class="kw-2">&amp;</span><span class="string">b"hing"</span>[..], <span class="kw-2">&amp;</span><span class="string">b"Somet"</span>[..])));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b"Some"</span>[..]), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="kw-2">&amp;</span><span class="string">b"Some"</span>[..], ErrorKind::Slice))));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b""</span>[..]), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="kw-2">&amp;</span><span class="string">b""</span>[..], ErrorKind::Slice))));</code></pre></div>
</div><section id="impl-Parser%3CI,+%3CI+as+Stream%3E::Slice,+E%3E-for-Caseless%3C%26%5Bu8;+N%5D%3E" class="impl"><a class="src rightside" href="../src/winnow/parser.rs.html#886-896">source</a><a href="#impl-Parser%3CI,+%3CI+as+Stream%3E::Slice,+E%3E-for-Caseless%3C%26%5Bu8;+N%5D%3E" class="anchor">§</a><h3 class="code-header">impl&lt;'s, I, E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;, const N: <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.usize.html">usize</a>&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, &lt;I as <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>&gt;::<a class="associatedtype" href="stream/trait.Stream.html#associatedtype.Slice" title="type winnow::stream::Stream::Slice">Slice</a>, E&gt; for <a class="struct" href="ascii/struct.Caseless.html" title="struct winnow::ascii::Caseless">Caseless</a>&lt;&amp;'s [<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.u8.html">u8</a>; <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.array.html">N</a>]&gt;<div class="where">where
I: <a class="trait" href="stream/trait.Compare.html" title="trait winnow::stream::Compare">Compare</a>&lt;<a class="struct" href="ascii/struct.Caseless.html" title="struct winnow::ascii::Caseless">Caseless</a>&lt;&amp;'s [<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.u8.html">u8</a>; <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.array.html">N</a>]&gt;&gt; + <a class="trait" href="stream/trait.StreamIsPartial.html" title="trait winnow::stream::StreamIsPartial">StreamIsPartial</a> + <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,</div></h3></section><div class="docblock"><p>This is a shortcut for <a href="token/fn.literal.html" title="fn winnow::token::literal"><code>literal</code></a>.</p>
<h4 id="example-24"><a href="#example-24">Example</a></h4>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>winnow::ascii::Caseless;
<span class="kw">fn </span>parser&lt;<span class="lifetime">'s</span>&gt;(s: <span class="kw-2">&amp;mut &amp;</span><span class="lifetime">'s </span>[u8]) -&gt; PResult&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>[u8], InputError&lt;<span class="kw-2">&amp;</span><span class="lifetime">'s </span>[u8]&gt;&gt; {
alt((Caseless(<span class="string">b"hello"</span>), take(<span class="number">5usize</span>))).parse_next(s)
}
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b"Hello, World!"</span>[..]), <span class="prelude-val">Ok</span>((<span class="kw-2">&amp;</span><span class="string">b", World!"</span>[..], <span class="kw-2">&amp;</span><span class="string">b"Hello"</span>[..])));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b"hello, World!"</span>[..]), <span class="prelude-val">Ok</span>((<span class="kw-2">&amp;</span><span class="string">b", World!"</span>[..], <span class="kw-2">&amp;</span><span class="string">b"hello"</span>[..])));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b"HeLlo, World!"</span>[..]), <span class="prelude-val">Ok</span>((<span class="kw-2">&amp;</span><span class="string">b", World!"</span>[..], <span class="kw-2">&amp;</span><span class="string">b"HeLlo"</span>[..])));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b"Something"</span>[..]), <span class="prelude-val">Ok</span>((<span class="kw-2">&amp;</span><span class="string">b"hing"</span>[..], <span class="kw-2">&amp;</span><span class="string">b"Somet"</span>[..])));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b"Some"</span>[..]), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="kw-2">&amp;</span><span class="string">b"Some"</span>[..], ErrorKind::Slice))));
<span class="macro">assert_eq!</span>(parser.parse_peek(<span class="kw-2">&amp;</span><span class="string">b""</span>[..]), <span class="prelude-val">Err</span>(ErrMode::Backtrack(InputError::new(<span class="kw-2">&amp;</span><span class="string">b""</span>[..], ErrorKind::Slice))));</code></pre></div>
</div><section id="impl-Parser%3CI,+O2,+E%3E-for-FlatMap%3CF,+G,+H,+I,+O,+O2,+E%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#350-361">source</a><a href="#impl-Parser%3CI,+O2,+E%3E-for-FlatMap%3CF,+G,+H,+I,+O,+O2,+E%3E" class="anchor">§</a><h3 class="code-header">impl&lt;F, G, H, I, O, O2, E&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt; for <a class="struct" href="combinator/struct.FlatMap.html" title="struct winnow::combinator::FlatMap">FlatMap</a>&lt;F, G, H, I, O, O2, E&gt;<div class="where">where
F: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt;,
G: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(O) -&gt; H,
H: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt;,</div></h3></section><section id="impl-Parser%3CI,+O2,+E%3E-for-AndThen%3CF,+G,+I,+O,+O2,+E%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#238-256">source</a><a href="#impl-Parser%3CI,+O2,+E%3E-for-AndThen%3CF,+G,+I,+O,+O2,+E%3E" class="anchor">§</a><h3 class="code-header">impl&lt;F, G, I, O, O2, E&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt; for <a class="struct" href="combinator/struct.AndThen.html" title="struct winnow::combinator::AndThen">AndThen</a>&lt;F, G, I, O, O2, E&gt;<div class="where">where
F: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt;,
G: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;O, O2, E&gt;,
O: <a class="trait" href="stream/trait.StreamIsPartial.html" title="trait winnow::stream::StreamIsPartial">StreamIsPartial</a>,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,</div></h3></section><section id="impl-Parser%3CI,+O2,+E%3E-for-Map%3CF,+G,+I,+O,+O2,+E%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#71-83">source</a><a href="#impl-Parser%3CI,+O2,+E%3E-for-Map%3CF,+G,+I,+O,+O2,+E%3E" class="anchor">§</a><h3 class="code-header">impl&lt;F, G, I, O, O2, E&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt; for <a class="struct" href="combinator/struct.Map.html" title="struct winnow::combinator::Map">Map</a>&lt;F, G, I, O, O2, E&gt;<div class="where">where
F: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt;,
G: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(O) -&gt; O2,</div></h3></section><section id="impl-Parser%3CI,+O2,+E%3E-for-VerifyMap%3CF,+G,+I,+O,+O2,+E%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#181-199">source</a><a href="#impl-Parser%3CI,+O2,+E%3E-for-VerifyMap%3CF,+G,+I,+O,+O2,+E%3E" class="anchor">§</a><h3 class="code-header">impl&lt;F, G, I, O, O2, E&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt; for <a class="struct" href="combinator/struct.VerifyMap.html" title="struct winnow::combinator::VerifyMap">VerifyMap</a>&lt;F, G, I, O, O2, E&gt;<div class="where">where
F: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt;,
G: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(O) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a>&lt;O2&gt;,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,
E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;,</div></h3></section><section id="impl-Parser%3CI,+O,+E%3E-for-Verify%3CF,+G,+I,+O,+O2,+E%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#437-457">source</a><a href="#impl-Parser%3CI,+O,+E%3E-for-Verify%3CF,+G,+I,+O,+O2,+E%3E" class="anchor">§</a><h3 class="code-header">impl&lt;F, G, I, O, O2, E&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt; for <a class="struct" href="combinator/struct.Verify.html" title="struct winnow::combinator::Verify">Verify</a>&lt;F, G, I, O, O2, E&gt;<div class="where">where
F: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt;,
G: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.reference.html">&amp;O2</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.bool.html">bool</a>,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,
O: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a>&lt;O2&gt;,
O2: ?<a class="trait" href="https://doc.rust-lang.org/1.76.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;,</div></h3></section><section id="impl-Parser%3CI,+O2,+E%3E-for-TryMap%3CF,+G,+I,+O,+O2,+E,+E2%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#124-142">source</a><a href="#impl-Parser%3CI,+O2,+E%3E-for-TryMap%3CF,+G,+I,+O,+O2,+E,+E2%3E" class="anchor">§</a><h3 class="code-header">impl&lt;F, G, I, O, O2, E, E2&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt; for <a class="struct" href="combinator/struct.TryMap.html" title="struct winnow::combinator::TryMap">TryMap</a>&lt;F, G, I, O, O2, E, E2&gt;<div class="where">where
F: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt;,
G: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(O) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.76.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;O2, E2&gt;,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,
E: <a class="trait" href="error/trait.FromExternalError.html" title="trait winnow::error::FromExternalError">FromExternalError</a>&lt;I, E2&gt;,</div></h3></section><section id="impl-Parser%3CI,+(O,+%3CI+as+Stream%3E::Slice),+E%3E-for-WithRecognized%3CF,+I,+O,+E%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#658-676">source</a><a href="#impl-Parser%3CI,+(O,+%3CI+as+Stream%3E::Slice),+E%3E-for-WithRecognized%3CF,+I,+O,+E%3E" class="anchor">§</a><h3 class="code-header">impl&lt;F, I, O, E&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, (O, &lt;I as <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>&gt;::<a class="associatedtype" href="stream/trait.Stream.html#associatedtype.Slice" title="type winnow::stream::Stream::Slice">Slice</a>), E&gt; for <a class="struct" href="combinator/struct.WithRecognized.html" title="struct winnow::combinator::WithRecognized">WithRecognized</a>&lt;F, I, O, E&gt;<div class="where">where
F: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt;,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,</div></h3></section><section id="impl-Parser%3CI,+(O,+Range%3Cusize%3E),+E%3E-for-WithSpan%3CF,+I,+O,+E%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#751-764">source</a><a href="#impl-Parser%3CI,+(O,+Range%3Cusize%3E),+E%3E-for-WithSpan%3CF,+I,+O,+E%3E" class="anchor">§</a><h3 class="code-header">impl&lt;F, I, O, E&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, (O, <a class="struct" href="https://doc.rust-lang.org/1.76.0/core/ops/range/struct.Range.html" title="struct core::ops::range::Range">Range</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.usize.html">usize</a>&gt;), E&gt; for <a class="struct" href="combinator/struct.WithSpan.html" title="struct winnow::combinator::WithSpan">WithSpan</a>&lt;F, I, O, E&gt;<div class="where">where
F: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt;,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a> + <a class="trait" href="stream/trait.Location.html" title="trait winnow::stream::Location">Location</a>,</div></h3></section><section id="impl-Parser%3CI,+(),+E%3E-for-Void%3CF,+I,+O,+E%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#570-578">source</a><a href="#impl-Parser%3CI,+(),+E%3E-for-Void%3CF,+I,+O,+E%3E" class="anchor">§</a><h3 class="code-header">impl&lt;F, I, O, E&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.unit.html">()</a>, E&gt; for <a class="struct" href="combinator/struct.Void.html" title="struct winnow::combinator::Void">Void</a>&lt;F, I, O, E&gt;<div class="where">where
F: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt;,</div></h3></section><section id="impl-Parser%3CI,+O,+E%3E-for-CompleteErr%3CF%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#376-394">source</a><a href="#impl-Parser%3CI,+O,+E%3E-for-CompleteErr%3CF%3E" class="anchor">§</a><h3 class="code-header">impl&lt;F, I, O, E&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt; for <a class="struct" href="combinator/struct.CompleteErr.html" title="struct winnow::combinator::CompleteErr">CompleteErr</a>&lt;F&gt;<div class="where">where
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,
F: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt;,
E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;,</div></h3></section><section id="impl-Parser%3CI,+O,+E%3E-for-Context%3CF,+I,+O,+E,+C%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#890-908">source</a><a href="#impl-Parser%3CI,+O,+E%3E-for-Context%3CF,+I,+O,+E,+C%3E" class="anchor">§</a><h3 class="code-header">impl&lt;F, I, O, E, C&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt; for <a class="struct" href="combinator/struct.Context.html" title="struct winnow::combinator::Context">Context</a>&lt;F, I, O, E, C&gt;<div class="where">where
F: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt;,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,
E: <a class="trait" href="error/trait.AddContext.html" title="trait winnow::error::AddContext">AddContext</a>&lt;I, C&gt;,
C: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a>,</div></h3></section><section id="impl-Parser%3CI,+O,+E2%3E-for-ErrInto%3CF,+I,+O,+E,+E2%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#839-853">source</a><a href="#impl-Parser%3CI,+O,+E2%3E-for-ErrInto%3CF,+I,+O,+E,+E2%3E" class="anchor">§</a><h3 class="code-header">impl&lt;F, I, O, E, E2&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E2&gt; for <a class="struct" href="combinator/struct.ErrInto.html" title="struct winnow::combinator::ErrInto">ErrInto</a>&lt;F, I, O, E, E2&gt;<div class="where">where
F: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt;,
E: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;E2&gt;,</div></h3></section><section id="impl-Parser%3CI,+O2,+E%3E-for-DefaultValue%3CF,+I,+O,+O2,+E%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#532-541">source</a><a href="#impl-Parser%3CI,+O2,+E%3E-for-DefaultValue%3CF,+I,+O,+O2,+E%3E" class="anchor">§</a><h3 class="code-header">impl&lt;F, I, O, O2, E&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt; for <a class="struct" href="combinator/struct.DefaultValue.html" title="struct winnow::combinator::DefaultValue">DefaultValue</a>&lt;F, I, O, O2, E&gt;<div class="where">where
F: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt;,
O2: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/default/trait.Default.html" title="trait core::default::Default">Default</a>,</div></h3></section><section id="impl-Parser%3CI,+O2,+E%3E-for-OutputInto%3CF,+I,+O,+O2,+E%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#797-806">source</a><a href="#impl-Parser%3CI,+O2,+E%3E-for-OutputInto%3CF,+I,+O,+O2,+E%3E" class="anchor">§</a><h3 class="code-header">impl&lt;F, I, O, O2, E&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt; for <a class="struct" href="combinator/struct.OutputInto.html" title="struct winnow::combinator::OutputInto">OutputInto</a>&lt;F, I, O, O2, E&gt;<div class="where">where
F: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt;,
O: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;O2&gt;,</div></h3></section><section id="impl-Parser%3CI,+O2,+E%3E-for-Value%3CF,+I,+O,+O2,+E%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#490-499">source</a><a href="#impl-Parser%3CI,+O2,+E%3E-for-Value%3CF,+I,+O,+O2,+E%3E" class="anchor">§</a><h3 class="code-header">impl&lt;F, I, O, O2, E&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt; for <a class="struct" href="combinator/struct.Value.html" title="struct winnow::combinator::Value">Value</a>&lt;F, I, O, O2, E&gt;<div class="where">where
F: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt;,
O2: <a class="trait" href="https://doc.rust-lang.org/1.76.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>,</div></h3></section><section id="impl-Parser%3CI,+%3CI+as+Stream%3E::Slice,+E%3E-for-Recognize%3CF,+I,+O,+E%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#609-627">source</a><a href="#impl-Parser%3CI,+%3CI+as+Stream%3E::Slice,+E%3E-for-Recognize%3CF,+I,+O,+E%3E" class="anchor">§</a><h3 class="code-header">impl&lt;I, O, E, F&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, &lt;I as <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>&gt;::<a class="associatedtype" href="stream/trait.Stream.html#associatedtype.Slice" title="type winnow::stream::Stream::Slice">Slice</a>, E&gt; for <a class="struct" href="combinator/struct.Recognize.html" title="struct winnow::combinator::Recognize">Recognize</a>&lt;F, I, O, E&gt;<div class="where">where
F: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt;,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,</div></h3></section><section id="impl-Parser%3CI,+Range%3Cusize%3E,+E%3E-for-Span%3CF,+I,+O,+E%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#707-720">source</a><a href="#impl-Parser%3CI,+Range%3Cusize%3E,+E%3E-for-Span%3CF,+I,+O,+E%3E" class="anchor">§</a><h3 class="code-header">impl&lt;I, O, E, F&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, <a class="struct" href="https://doc.rust-lang.org/1.76.0/core/ops/range/struct.Range.html" title="struct core::ops::range::Range">Range</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.76.0/std/primitive.usize.html">usize</a>&gt;, E&gt; for <a class="struct" href="combinator/struct.Span.html" title="struct winnow::combinator::Span">Span</a>&lt;F, I, O, E&gt;<div class="where">where
F: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt;,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a> + <a class="trait" href="stream/trait.Location.html" title="trait winnow::stream::Location">Location</a>,</div></h3></section><section id="impl-Parser%3CI,+C,+E%3E-for-Repeat%3CP,+I,+O,+C,+E%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/multi.rs.html#278-301">source</a><a href="#impl-Parser%3CI,+C,+E%3E-for-Repeat%3CP,+I,+O,+C,+E%3E" class="anchor">§</a><h3 class="code-header">impl&lt;P, I, O, C, E&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, C, E&gt; for <a class="struct" href="combinator/struct.Repeat.html" title="struct winnow::combinator::Repeat">Repeat</a>&lt;P, I, O, C, E&gt;<div class="where">where
P: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt;,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,
C: <a class="trait" href="stream/trait.Accumulate.html" title="trait winnow::stream::Accumulate">Accumulate</a>&lt;O&gt;,
E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;,</div></h3></section><section id="impl-Parser%3CI,+O2,+E%3E-for-ParseTo%3CP,+I,+O,+O2,+E%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#293-311">source</a><a href="#impl-Parser%3CI,+O2,+E%3E-for-ParseTo%3CP,+I,+O,+O2,+E%3E" class="anchor">§</a><h3 class="code-header">impl&lt;P, I, O, O2, E&gt; <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O2, E&gt; for <a class="struct" href="combinator/struct.ParseTo.html" title="struct winnow::combinator::ParseTo">ParseTo</a>&lt;P, I, O, O2, E&gt;<div class="where">where
P: <a class="trait" href="trait.Parser.html" title="trait winnow::Parser">Parser</a>&lt;I, O, E&gt;,
I: <a class="trait" href="stream/trait.Stream.html" title="trait winnow::stream::Stream">Stream</a>,
O: <a class="trait" href="stream/trait.ParseSlice.html" title="trait winnow::stream::ParseSlice">ParseSlice</a>&lt;O2&gt;,
E: <a class="trait" href="error/trait.ParserError.html" title="trait winnow::error::ParserError">ParserError</a>&lt;I&gt;,</div></h3></section></div><script src="../trait.impl/winnow/parser/trait.Parser.js" data-ignore-extern-crates="std,alloc" async></script></section></div></main></body></html>
Reference in a new issue View git blame Copy permalink