edlang/winnow/trait.Parser.html

881 lines
206 KiB
HTML
Raw Normal View History

<!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><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-46f98efaafac5295.ttf.woff2,FiraSans-Regular-018c141bf0843ffd.woff2,FiraSans-Medium-8f9a781e4970d388.woff2,SourceCodePro-Regular-562dcc5011b6de7d.ttf.woff2,SourceCodePro-Semibold-d899c5a5c4aeb14a.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2" crossorigin href="../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../static.files/normalize-76eba96aa4d2e634.css"><link rel="stylesheet" href="../static.files/rustdoc-dd39b87e5fcfba68.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.80.0 (051478957 2024-07-21)" data-channel="1.80.0" data-search-js="search-d52510db62a78183.js" data-settings-js="settings-4313503d2e1961c2.js" ><script src="../static.files/storage-118b08c4c78b968e.js"></script><script defer src="sidebar-items.js"></script><script defer src="../static.files/main-20a3ad099b048cf2.js"></script><noscript><link rel="stylesheet" href="../static.files/noscript-df360f571f6edeae.css"></noscript><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" title="show sidebar"></button></nav><nav class="sidebar"><div class="sidebar-crate"><h2><a href="../winnow/index.html">winnow</a><span class="version">0.6.16</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.take">take</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><li><a href="#method.with_taken">with_taken</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>
<details class="toggle type-contents-toggle"><summary class="hideme"><span>Show 24 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.80.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.80.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.80.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>,
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.80.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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
O2: <a class="trait" href="https://doc.rust-lang.org/1.80.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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
O2: <a class="trait" href="https://doc.rust-lang.org/1.80.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.80.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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
O: <a class="trait" href="https://doc.rust-lang.org/1.80.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.take" class="fn">take</a>(self) -&gt; <a class="struct" href="combinator/struct.Take.html" title="struct winnow::combinator::Take">Take</a>&lt;Self, I, O, E&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.80.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.recognize" class="fn">recognize</a>(self) -&gt; <a class="struct" href="combinator/struct.Take.html" title="struct winnow::combinator::Take">Take</a>&lt;Self, I, O, E&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.80.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_taken" class="fn">with_taken</a>(self) -&gt; <a class="struct" href="combinator/struct.WithTaken.html" title="struct winnow::combinator::WithTaken">WithTaken</a>&lt;Self, I, O, E&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.80.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.WithTaken.html" title="struct winnow::combinator::WithTaken">WithTaken</a>&lt;Self, I, O, E&gt;
<span class="where">where Self: <a class="trait" href="https://doc.rust-lang.org/1.80.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.80.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.80.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.80.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.80.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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
G: <a class="trait" href="https://doc.rust-lang.org/1.80.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.80.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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
G: <a class="trait" href="https://doc.rust-lang.org/1.80.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.80.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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
G: <a class="trait" href="https://doc.rust-lang.org/1.80.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.80.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.80.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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
G: <a class="trait" href="https://doc.rust-lang.org/1.80.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.80.0/std/primitive.reference.html">&amp;O2</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.80.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.80.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.80.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.80.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.80.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.80.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.80.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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
E: <a class="trait" href="https://doc.rust-lang.org/1.80.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#81">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.80.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#51-74">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.80.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.80.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>,
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#87-92">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#138-143">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.80.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 class="doc-anchor" href="#example">§</a>Example</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#162-168">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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
O2: <a class="trait" href="https://doc.rust-lang.org/1.80.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 class="doc-anchor" href="#example-1">§</a>Example</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#186-192">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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
O2: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/default/trait.Default.html" title="trait core::default::Default">Default</a>,</div></h4></section></summary><div class="docblock"><p>Produce a types default value</p>
<h5 id="example-2"><a class="doc-anchor" href="#example-2">§</a>Example</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#210-215">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.80.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 class="doc-anchor" href="#example-3">§</a>Example</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#239-245">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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
O: <a class="trait" href="https://doc.rust-lang.org/1.80.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 parsers output to another type using <a href="https://doc.rust-lang.org/1.80.0/core/convert/trait.From.html" title="trait core::convert::From"><code>std::convert::From</code></a></p>
<h5 id="example-4"><a class="doc-anchor" href="#example-4">§</a>Example</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.take" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#266-272">source</a><h4 class="code-header">fn <a href="#method.take" class="fn">take</a>(self) -&gt; <a class="struct" href="combinator/struct.Take.html" title="struct winnow::combinator::Take">Take</a>&lt;Self, I, O, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.80.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 class="doc-anchor" href="#example-5">§</a>Example</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).take();
<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.recognize" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#277-283">source</a><h4 class="code-header">fn <a href="#method.recognize" class="fn">recognize</a>(self) -&gt; <a class="struct" href="combinator/struct.Take.html" title="struct winnow::combinator::Take">Take</a>&lt;Self, I, O, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.80.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><span class="item-info"><div class="stab deprecated"><span class="emoji">👎</span><span>Deprecated since 0.6.14: Replaced with <code>Parser::take</code></span></div></span></summary><div class="docblock"><p>Replaced with <a href="trait.Parser.html#method.take" title="method winnow::Parser::take"><code>Parser::take</code></a></p>
</div></details><details class="toggle method-toggle" open><summary><section id="method.with_taken" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#324-330">source</a><h4 class="code-header">fn <a href="#method.with_taken" class="fn">with_taken</a>(self) -&gt; <a class="struct" href="combinator/struct.WithTaken.html" title="struct winnow::combinator::WithTaken">WithTaken</a>&lt;Self, I, O, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.80.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.take" title="method winnow::Parser::take">take</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 class="doc-anchor" href="#example-6">§</a>Example</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_taken();
<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 `take` parser.
</span><span class="kw">let </span><span class="kw-2">mut </span>take_parser = inner_parser.take();
<span class="kw">let </span><span class="kw-2">mut </span>consumed_parser = inner_parser.with_taken().map(|(output, consumed)| consumed);
<span class="macro">assert_eq!</span>(take_parser.parse_peek(<span class="string">"1234"</span>), consumed_parser.parse_peek(<span class="string">"1234"</span>));
<span class="macro">assert_eq!</span>(take_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.with_recognized" class="method"><a class="src rightside" href="../src/winnow/parser.rs.html#335-341">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.WithTaken.html" title="struct winnow::combinator::WithTaken">WithTaken</a>&lt;Self, I, O, E&gt;<div class="where">where
Self: <a class="trait" href="https://doc.rust-lang.org/1.80.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><span class="item-info"><div class="stab deprecated"><span class="emoji">👎</span><span>Deprecated since 0.6.14: Replaced with <code>Parser::with_taken</code></span></div></span></summary><div class="docblock"><p>Replaced with <a href="trait.Parser.html#method.with_taken" title="method winnow::Parser::with_taken"><code>Parser::with_taken</code></a></p>
</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#360-366">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.80.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 class="doc-anchor" href="#example-7">§</a>Example</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#409-415">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.80.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 class="doc-anchor" href="#example-8">§</a>Example</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>span_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>(span_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>(span_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#436-442">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.80.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.80.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 class="doc-anchor" href="#example-9">§</a>Example</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#466-474">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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
G: <a class="trait" href="https://doc.rust-lang.org/1.80.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.80.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 class="doc-anchor" href="#example-10">§</a>Example</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#501-509">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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
G: <a class="trait" href="https://doc.rust-lang.org/1.80.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.80.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 class="doc-anchor" href="#example-11">§</a>Example</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#544-551">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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
G: <a class="trait" href="https://doc.rust-lang.org/1.80.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 class="doc-anchor" href="#example-12">§</a>Example</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#571-579">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.80.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 class="doc-anchor" href="#example-13">§</a>Example</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#602-610">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.80.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.80.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 class="doc-anchor" href="#example-14">§</a>Example</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#634-644">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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
G: <a class="trait" href="https://doc.rust-lang.org/1.80.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.80.0/std/primitive.reference.html">&amp;O2</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.80.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.80.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.80.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 class="doc-anchor" href="#example-15">§</a>Example</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#652-660">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.80.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.80.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.80.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#678-683">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.80.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 class="doc-anchor" href="#example-16">§</a>Example</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#687-693">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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
E: <a class="trait" href="https://doc.rust-lang.org/1.80.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 parsers error to another type using <a href="https://doc.rust-lang.org/1.80.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#1120-1125">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.80.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#1122-1124">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.80.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#87-92">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#138-143">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.80.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#162-168">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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
O2: <a class="trait" href="https://doc.rust-lang.org/1.80.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#186-192">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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
O2: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/default/trait.Default.html" title="trait core::default::Default">Default</a>,</div></h4></section></summary><div class='docblock'>Produce a types 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#210-215">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.80.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#239-245">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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
O: <a class="trait" href="https://doc.rust-lang.org/1.80.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 parsers output to another type using <a href="https://doc.rust-lang.org/1.80.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#436-442">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.80.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.80.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#544-551">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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
G: <a class="trait" href="https://doc.rust-lang.org/1.80.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#678-683">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.80.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#687-693">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.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
E: <a class="trait" href="https://doc.rust-lang.org/1.80.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 parsers error to another type using <a href="https://doc.rust-lang.org/1.80.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#1120-1125">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.80.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#1122-1124">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.80.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#943-952">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.80.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.80.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 class="doc-anchor" href="#example-17">§</a>Example</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#949-951">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.80.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#820-829">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.80.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.80.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 class="doc-anchor" href="#example-18">§</a>Example</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#826-828">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.80.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#881-890">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.80.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.80.0/std/primitive.u8.html">u8</a>; <a class="primitive" href="https://doc.rust-lang.org/1.80.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.80.0/std/primitive.u8.html">u8</a>; <a class="primitive" href="https://doc.rust-lang.org/1.80.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 class="doc-anchor" href="#example-19">§</a>Example</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#887-889">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.80.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#789-800">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.80.0/std/primitive.char.html">char</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.80.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.80.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 class="doc-anchor" href="#example-20">§</a>Example</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#797-799">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.80.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.80.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#761-772">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.80.0/std/primitive.u8.html">u8</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.80.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.80.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 class="doc-anchor" href="#example-21">§</a>Example</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#769-771">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.80.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.80.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#986-991">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.80.0/std/primitive.unit.html">()</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.80.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#988-990">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.80.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.80.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#1092-1114">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.80.0/std/primitive.tuple.html">(O1,)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.0/std/primitive.tuple.html">(O1, O2)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.0/std/primitive.tuple.html">(O1, O2, O3)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.0/std/primitive.tuple.html">(O1, O2, O3, O4)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.0/std/primitive.tuple.html">(O1, O2, O3, O4, O5)</a>, E&gt; for <a class="primitive" href="https://doc.rust-lang.org/1.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#1092-1114">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.80.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.80.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#735-744">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.80.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.80.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#30-38">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#975-984">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.80.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.80.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 class="doc-anchor" href="#example-22">§</a>Example</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#852-861">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.80.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.80.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 class="doc-anchor" href="#example-23">§</a>Example</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#913-923">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.80.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.80.0/std/primitive.u8.html">u8</a>; <a class="primitive" href="https://doc.rust-lang.org/1.80.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.80.0/std/primitive.u8.html">u8</a>; <a class="primitive" href="https://doc.rust-lang.org/1.80.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 class="doc-anchor" href="#example-24">§</a>Example</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#352-363">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.80.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#240-258">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#73-85">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.80.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#183-201">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.80.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.80.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#439-459">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.80.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.80.0/std/primitive.reference.html">&amp;O2</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.80.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.80.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.80.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#126-144">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.80.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.80.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-WithTaken%3CF,+I,+O,+E%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#668-686">source</a><a href="#impl-Parser%3CI,+(O,+%3CI+as+Stream%3E::Slice),+E%3E-for-WithTaken%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.WithTaken.html" title="struct winnow::combinator::WithTaken">WithTaken</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#761-774">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.80.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.80.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#572-580">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.80.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#378-396">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#900-918">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.80.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/1.80.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#849-863">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.80.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#534-543">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.80.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#807-816">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.80.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#492-501">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.80.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-Take%3CF,+I,+O,+E%3E" class="impl"><a class="src rightside" href="../src/winnow/combinator/parser.rs.html#615-633">source</a><a href="#impl-Parser%3CI,+%3CI+as+Stream%3E::Slice,+E%3E-for-Take%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.Take.html" title="struct winnow::combinator::Take">Take</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#717-730">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.80.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.80.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#280-303">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#295-313">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>