485 lines
588 KiB
HTML
485 lines
588 KiB
HTML
|
<!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="API documentation for the Rust `Parser` trait in crate `combine`.">
|
|||
|
|
<meta name="keywords" content="rust, rustlang, rust-lang, Parser">
|
|||
|
|
|
|||
|
|
<title>combine::primitives::Parser - Rust</title>
|
|||
|
|
|
|||
|
|
<link rel="stylesheet" type="text/css" href="../../normalize.css">
|
|||
|
|
<link rel="stylesheet" type="text/css" href="../../rustdoc.css"
|
|||
|
|
id="mainThemeStyle">
|
|||
|
|
|
|||
|
|
<link rel="stylesheet" type="text/css" href="../../dark.css">
|
|||
|
|
<link rel="stylesheet" type="text/css" href="../../light.css" id="themeStyle">
|
|||
|
|
<script src="../../storage.js"></script>
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
</head>
|
|||
|
|
<body class="rustdoc trait">
|
|||
|
|
<!--[if lte IE 8]>
|
|||
|
|
<div class="warning">
|
|||
|
|
This old browser is unsupported and will most likely display funky
|
|||
|
|
things.
|
|||
|
|
</div>
|
|||
|
|
<![endif]-->
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
<nav class="sidebar">
|
|||
|
|
<div class="sidebar-menu">☰</div>
|
|||
|
|
|
|||
|
|
<p class='location'>Trait Parser</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#associated-types">Associated Types</a><div class="sidebar-links"><a href="#associatedtype.Input">Input</a><a href="#associatedtype.Output">Output</a></div><a class="sidebar-title" href="#provided-methods">Provided Methods</a><div class="sidebar-links"><a href="#method.parse">parse</a><a href="#method.parse_stream">parse_stream</a><a href="#method.parse_stream_consumed">parse_stream_consumed</a><a href="#method.parse_lazy">parse_lazy</a><a href="#method.add_error">add_error</a><a href="#method.by_ref">by_ref</a><a href="#method.with">with</a><a href="#method.skip">skip</a><a href="#method.and">and</a><a href="#method.or">or</a><a href="#method.then">then</a><a href="#method.map">map</a><a href="#method.flat_map">flat_map</a><a href="#method.message">message</a><a href="#method.expected">expected</a><a href="#method.and_then">and_then</a><a href="#method.iter">iter</a><a href="#method.boxed">boxed</a></div><a class="sidebar-title" href="#foreign-impls">Implementations on Foreign Types</a><div class="sidebar-links"><a href="#impl-Parser">&'a mut P</a><a href="#impl-Parser">Box<P></a><a href="#impl-Parser">FnMut(I) -> ParseResult<O, I> + 'a</a><a href="#impl-Parser">fn(_: I) -> ParseResult<O, I></a><a href="#impl-Parser">(A, B)</a><a href="#impl-Parser">(A, B, C)</a><a href="#impl-Parser">(A, B, C, D)</a><a href="#impl-Parser">(A, B, C, D, E)</a><a href="#impl-Parser">(A, B, C, D, E, F)</a><a href="#impl-Parser">(A, B, C, D, E, F, G)</a><a href="#impl-Parser">(A, B, C, D, E, F, G, H)</a><a href="#impl-Parser">(A, B, C, D, E, F, G, H, I)</a><a href="#impl-Parser">(A, B, C, D, E, F, G, H, I, J)</a><a href="#impl-Parser">(A, B, C, D, E, F, G, H, I, J, K)</a><a href="#impl-Parser">(A, B, C, D, E, F, G, H, I, J, K, L)</a></div><a class="sidebar-title" href="#implementors">Implementors</a></div><p class='location'><a href='../index.html'>combine</a>::<wbr><a href='index.html'>primitives</a></p><script>window.sidebarCurrent = {name: 'Parser', ty: 'trait', relpath: ''};</script><script defer src="sidebar-items.js"></script></div>
|
|||
|
|
</nav>
|
|||
|
|
|
|||
|
|
<div class="theme-picker">
|
|||
|
|
<button id="theme-picker" aria-label="Pick another theme!">
|
|||
|
|
<img src="../../brush.svg" width="18" alt="Pick another theme!">
|
|||
|
|
</button>
|
|||
|
|
<div id="theme-choices"></div>
|
|||
|
|
</div>
|
|||
|
|
<script src="../../theme.js"></script>
|
|||
|
|
<nav class="sub">
|
|||
|
|
<form class="search-form js-only">
|
|||
|
|
<div class="search-container">
|
|||
|
|
<input class="search-input" name="search"
|
|||
|
|
autocomplete="off"
|
|||
|
|
placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
|
|||
|
|
type="search">
|
|||
|
|
</div>
|
|||
|
|
</form>
|
|||
|
|
</nav>
|
|||
|
|
|
|||
|
|
<section id='main' class="content"><h1 class='fqn'><span class='in-band'>Trait <a href='../index.html'>combine</a>::<wbr><a href='index.html'>primitives</a>::<wbr><a class="trait" href=''>Parser</a></span><span class='out-of-band'><span id='render-detail'>
|
|||
|
|
<a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
|
|||
|
|
[<span class='inner'>−</span>]
|
|||
|
|
</a>
|
|||
|
|
</span><a class='srclink' href='../../src/combine/primitives.rs.html#1383-1823' title='goto source code'>[src]</a></span></h1><div class="docblock type-decl"><pre class='rust trait'>pub trait Parser {
|
|||
|
|
type <a href='#associatedtype.Input' class="type">Input</a>: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>;
|
|||
|
|
type <a href='#associatedtype.Output' class="type">Output</a>;
|
|||
|
|
fn <a href='#method.parse' class='fnname'>parse</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br> ) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>> { ... }
|
|||
|
|
<div class='item-spacer'></div> fn <a href='#method.parse_stream' class='fnname'>parse_stream</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br> ) -> <a class="type" href="../../combine/type.ParseResult.html" title="type combine::ParseResult">ParseResult</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>> { ... }
|
|||
|
|
<div class='item-spacer'></div> fn <a href='#method.parse_stream_consumed' class='fnname'>parse_stream_consumed</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br> ) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>> { ... }
|
|||
|
|
<div class='item-spacer'></div> fn <a href='#method.parse_lazy' class='fnname'>parse_lazy</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br> ) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>> { ... }
|
|||
|
|
<div class='item-spacer'></div> fn <a href='#method.add_error' class='fnname'>add_error</a>(&mut self, _error: &mut <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>) { ... }
|
|||
|
|
<div class='item-spacer'></div> fn <a href='#method.by_ref' class='fnname'>by_ref</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>Self<br> <span class="where">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a></span>,
|
|||
|
|
{ ... }
|
|||
|
|
<div class='item-spacer'></div> fn <a href='#method.with' class='fnname'>with</a><P2>(self, p: P2) -> <a class="struct" href="../../combine/combinator/struct.With.html" title="struct combine::combinator::With">With</a><Self, P2><br> <span class="where">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,<br> P2: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>></span>,
|
|||
|
|
{ ... }
|
|||
|
|
<div class='item-spacer'></div> fn <a href='#method.skip' class='fnname'>skip</a><P2>(self, p: P2) -> <a class="struct" href="../../combine/combinator/struct.Skip.html" title="struct combine::combinator::Skip">Skip</a><Self, P2><br> <span class="where">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,<br> P2: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>></span>,
|
|||
|
|
{ ... }
|
|||
|
|
<div class='item-spacer'></div> fn <a href='#method.and' class='fnname'>and</a><P2>(self, p: P2) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self, P2<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a><br> <span class="where">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,<br> P2: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>></span>,
|
|||
|
|
{ ... }
|
|||
|
|
<div class='item-spacer'></div> fn <a href='#method.or' class='fnname'>or</a><P2>(self, p: P2) -> <a class="struct" href="../../combine/combinator/struct.Or.html" title="struct combine::combinator::Or">Or</a><Self, P2><br> <span class="where">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,<br> P2: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>, Output = Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>></span>,
|
|||
|
|
{ ... }
|
|||
|
|
<div class='item-spacer'></div> fn <a href='#method.then' class='fnname'>then</a><N, F>(self, f: F) -> <a class="struct" href="../../combine/combinator/struct.Then.html" title="struct combine::combinator::Then">Then</a><Self, F><br> <span class="where">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>) -> N,<br> N: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>></span>,
|
|||
|
|
{ ... }
|
|||
|
|
<div class='item-spacer'></div> fn <a href='#method.map' class='fnname'>map</a><F, B>(self, f: F) -> <a class="struct" href="../../combine/combinator/struct.Map.html" title="struct combine::combinator::Map">Map</a><Self, F><br> <span class="where">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>) -> B</span>,
|
|||
|
|
{ ... }
|
|||
|
|
<div class='item-spacer'></div> fn <a href='#method.flat_map' class='fnname'>flat_map</a><F, B>(self, f: F) -> <a class="struct" href="../../combine/combinator/struct.FlatMap.html" title="struct combine::combinator::FlatMap">FlatMap</a><Self, F><br> <span class="where">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><B, <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>></span>,
|
|||
|
|
{ ... }
|
|||
|
|
<div class='item-spacer'></div> fn <a href='#method.message' class='fnname'>message</a><S>(self, msg: S) -> <a class="struct" href="../../combine/combinator/struct.Message.html" title="struct combine::combinator::Message">Message</a><Self><br> <span class="where">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,<br> S: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><<a class="enum" href="../../combine/primitives/enum.Info.html" title="enum combine::primitives::Info">Info</a><<Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a> as <a class="trait" href="../../combine/trait.StreamOnce.html" title="trait combine::StreamOnce">StreamOnce</a>>::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>, <Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a> as <a class="trait" href="../../combine/trait.StreamOnce.html" title="trait combine::StreamOnce">StreamOnce</a>>::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Range" title="type combine::StreamOnce::Range">Range</a>>></span>,
|
|||
|
|
{ ... }
|
|||
|
|
<div class='item-spacer'></div> fn <a href='#method.expected' class='fnname'>expected</a><S>(self, msg: S) -> <a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><Self><br> <span class="where">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,<br> S: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><<a class="enum" href="../../combine/primitives/enum.Info.html" title="enum combine::primitives::Info">Info</a><<Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a> as <a class="trait" href="../../combine/trait.StreamOnce.html" title="trait combine::StreamOnce">StreamOnce</a>>::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>, <Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a> as <a class="trait" href="../../combine/trait.StreamOnce.html" title="trait combine::StreamOnce">StreamOnce</a>>::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Range" title="type combine::StreamOnce::Range">Range</a>>></span>,
|
|||
|
|
{ ... }
|
|||
|
|
<div class='item-spacer'></div> fn <a href='#method.and_then' class='fnname'>and_then</a><F, O, E>(self, f: F) -> <a class="struct" href="../../combine/combinator/struct.AndThen.html" title="struct combine::combinator::AndThen">AndThen</a><Self, F><br> <span class="where">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><O, E>,<br> E: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><<a class="enum" href="../../combine/primitives/enum.Error.html" title="enum combine::primitives::Error">Error</a><<Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a> as <a class="trait" href="../../combine/trait.StreamOnce.html" title="trait combine::StreamOnce">StreamOnce</a>>::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>, <Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a> as <a class="trait" href="../../combine/trait.StreamOnce.html" title="trait combine::StreamOnce">StreamOnce</a>>::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Range" title="type combine::StreamOnce::Range">Range</a>>></span>,
|
|||
|
|
{ ... }
|
|||
|
|
<div class='item-spacer'></div> fn <a href='#method.iter' class='fnname'>iter</a>(self, input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>) -> <a class="struct" href="../../combine/combinator/struct.Iter.html" title="struct combine::combinator::Iter">Iter</a><Self><br> <span class="where">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a></span>,
|
|||
|
|
{ ... }
|
|||
|
|
<div class='item-spacer'></div> fn <a href='#method.boxed' class='fnname'>boxed</a><'a>(<br> self<br> ) -> <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html" title="struct alloc::boxed::Box">Box</a><<a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>, Output = Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>> + 'a><br> <span class="where">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a> + 'a</span>,
|
|||
|
|
{ ... }
|
|||
|
|
}</pre></div><div class='docblock'><p>By implementing the <code>Parser</code> trait a type says that it can be used to parse an input stream
|
|||
|
|
into the type <code>Output</code>.</p>
|
|||
|
|
<p>All methods have a default implementation but there needs to be at least an implementation of
|
|||
|
|
<a href="trait.Parser.html#method.parse_stream"><code>parse_stream</code></a>, <a href="trait.Parser.html#method.parse_stream_consumed"><code>parse_stream_consumed</code></a>, or <a href="trait.Parser.html#method.parse_lazy"><code>parse_lazy</code></a>. If the last is implemented, an
|
|||
|
|
implementation of <a href="trait.Parser.html#method.add_error"><code>add_error</code></a> may also be required. See the documentation for
|
|||
|
|
<a href="trait.Parser.html#method.parse_lazy"><code>parse_lazy</code></a> for details.</p>
|
|||
|
|
</div>
|
|||
|
|
<h2 id='associated-types' class='small-section-header'>
|
|||
|
|
Associated Types<a href='#associated-types' class='anchor'></a>
|
|||
|
|
</h2>
|
|||
|
|
<div class='methods'>
|
|||
|
|
<h3 id='associatedtype.Input' class='method'><span id='Input.t' class='invisible'><code>type <a href='#associatedtype.Input' class="type">Input</a>: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a></code></span></h3><div class='docblock'><p>The type which is taken as input for the parser. The type must implement the <code>Stream</code> trait
|
|||
|
|
which allows the parser to read items from the type.</p>
|
|||
|
|
</div><h3 id='associatedtype.Output' class='method'><span id='Output.t' class='invisible'><code>type <a href='#associatedtype.Output' class="type">Output</a></code></span></h3><div class='docblock'><p>The type which is returned if the parser is successful.</p>
|
|||
|
|
</div></div>
|
|||
|
|
<h2 id='provided-methods' class='small-section-header'>
|
|||
|
|
Provided Methods<a href='#provided-methods' class='anchor'></a>
|
|||
|
|
</h2>
|
|||
|
|
<div class='methods'>
|
|||
|
|
<h3 id='method.parse' class='method'><span id='parse.v' class='invisible'><code>fn <a href='#method.parse' class='fnname'>parse</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>></code></span></h3><div class='docblock'><p>Entry point of the parser. Takes some input and tries to parse it.</p>
|
|||
|
|
<p>Returns the parsed result and the remaining input if the parser succeeds, or a
|
|||
|
|
<a href="struct.ParseError.html"><code>ParseError</code></a> otherwise.</p>
|
|||
|
|
</div><h3 id='method.parse_stream' class='method'><span id='parse_stream.v' class='invisible'><code>fn <a href='#method.parse_stream' class='fnname'>parse_stream</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="type" href="../../combine/type.ParseResult.html" title="type combine::ParseResult">ParseResult</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>></code></span></h3><div class='docblock'><p>Parses using the stream <code>input</code> by calling <a href="trait.StreamOnce.html#tymethod.uncons"><code>Stream::uncons</code></a> one or more times.</p>
|
|||
|
|
<p>On success returns <code>Ok((value, new_state))</code>, and on failure returns <code>Err(error)</code>.
|
|||
|
|
Furthermore <code>new_state</code> and <code>error</code> are wrapped in <a href="enum.Consumed.html"><code>Consumed</code></a>, providing information on
|
|||
|
|
whether this parser consumed any input data or not.</p>
|
|||
|
|
</div><h3 id='method.parse_stream_consumed' class='method'><span id='parse_stream_consumed.v' class='invisible'><code>fn <a href='#method.parse_stream_consumed' class='fnname'>parse_stream_consumed</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>></code></span></h3><div class='docblock'><p>Parses using the stream <code>input</code> by calling <a href="trait.StreamOnce.html#tymethod.uncons"><code>Stream::uncons</code></a> one or more times.</p>
|
|||
|
|
<p>Semantically equivalent to <a href="trait.Parser.html#method.parse_stream"><code>parse_stream</code></a>, except this method returns a flattened result
|
|||
|
|
type, combining <code>Result</code> and <a href="enum.Consumed.html"><code>Consumed</code></a> into a single <a href="enum.FastResult.html"><code>FastResult</code></a>.</p>
|
|||
|
|
</div><h3 id='method.parse_lazy' class='method'><span id='parse_lazy.v' class='invisible'><code>fn <a href='#method.parse_lazy' class='fnname'>parse_lazy</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>></code></span></h3><div class='docblock'><p>Parses using the stream <code>input</code> by calling <a href="trait.StreamOnce.html#tymethod.uncons"><code>Stream::uncons</code></a> one or more times.</p>
|
|||
|
|
<p>Specialized version of <a href="trait.Parser.html#method.parse_stream_consumed"><code>parse_stream_consumed</code></a> which permits error value creation to be
|
|||
|
|
skipped in the common case.</p>
|
|||
|
|
<p>When this parser returns <code>EmptyErr</code>, this method is allowed to return an empty
|
|||
|
|
<a href="struct.ParseError.html"><code>ParseError</code></a>. The error value that would have been returned can instead be obtained by
|
|||
|
|
calling <a href="trait.Parser.html#method.add_error"><code>add_error</code></a>. This allows a parent parser such as <code>choice</code> to skip the creation of
|
|||
|
|
an unnecessary error value, if an alternative parser succeeds.</p>
|
|||
|
|
<p>External callers should never have to call this function directly.</p>
|
|||
|
|
<p>Parsers should seek to implement this function instead of the above two, if errors can be
|
|||
|
|
encountered before consuming input. The default implementation always returns all errors,
|
|||
|
|
with <a href="trait.Parser.html#method.add_error"><code>add_error</code></a> being a no-op.</p>
|
|||
|
|
</div><h3 id='method.add_error' class='method'><span id='add_error.v' class='invisible'><code>fn <a href='#method.add_error' class='fnname'>add_error</a>(&mut self, _error: &mut <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>)</code></span></h3><div class='docblock'><p>Adds the first error that would normally be returned by this parser if it failed with an
|
|||
|
|
<code>EmptyErr</code> result.</p>
|
|||
|
|
<p>See <a href="trait.Parser.html#method.parse_lazy"><code>parse_lazy</code></a> for details.</p>
|
|||
|
|
</div><h3 id='method.by_ref' class='method'><span id='by_ref.v' class='invisible'><code>fn <a href='#method.by_ref' class='fnname'>by_ref</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&mut </a>Self <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></code></span></h3><div class='docblock'><p>Borrows a parser instead of consuming it.</p>
|
|||
|
|
<p>Used to apply parser combinators on <code>self</code> without losing ownership.</p>
|
|||
|
|
|
|||
|
|
<pre class="rust rust-example-rendered">
|
|||
|
|
<span class="kw">fn</span> <span class="ident">test</span>() <span class="op">-></span> <span class="ident">ParseResult</span><span class="op"><</span>(<span class="ident">char</span>, <span class="ident">char</span>), <span class="kw-2">&</span><span class="lifetime">'static</span> <span class="ident">str</span><span class="op">></span> {
|
|||
|
|
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">p</span> <span class="op">=</span> <span class="ident">digit</span>();
|
|||
|
|
<span class="kw">let</span> ((<span class="ident">d</span>, <span class="kw">_</span>), <span class="ident">input</span>) <span class="op">=</span> <span class="macro">try</span><span class="macro">!</span>((<span class="ident">p</span>.<span class="ident">by_ref</span>(), <span class="ident">letter</span>()).<span class="ident">parse_stream</span>(<span class="string">"1a23"</span>));
|
|||
|
|
<span class="kw">let</span> (<span class="ident">d2</span>, <span class="ident">input</span>) <span class="op">=</span> <span class="macro">try</span><span class="macro">!</span>(<span class="ident">input</span>.<span class="ident">combine</span>(<span class="op">|</span><span class="ident">input</span><span class="op">|</span> <span class="ident">p</span>.<span class="ident">parse_stream</span>(<span class="ident">input</span>)));
|
|||
|
|
<span class="prelude-val">Ok</span>(((<span class="ident">d</span>, <span class="ident">d2</span>), <span class="ident">input</span>))
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
<span class="kw">fn</span> <span class="ident">main</span>() {
|
|||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">test</span>(), <span class="prelude-val">Ok</span>(((<span class="string">'1'</span>, <span class="string">'2'</span>), <span class="ident">Consumed</span>::<span class="ident">Consumed</span>(<span class="string">"3"</span>))));
|
|||
|
|
}</pre>
|
|||
|
|
</div><h3 id='method.with' class='method'><span id='with.v' class='invisible'><code>fn <a href='#method.with' class='fnname'>with</a><P2>(self, p: P2) -> <a class="struct" href="../../combine/combinator/struct.With.html" title="struct combine::combinator::With">With</a><Self, P2> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,<br> P2: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>, </span></code></span></h3><div class='docblock'><p>Discards the value of the <code>self</code> parser and returns the value of <code>p</code>.
|
|||
|
|
Fails if any of the parsers fails.</p>
|
|||
|
|
|
|||
|
|
<pre class="rust rust-example-rendered">
|
|||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">digit</span>()
|
|||
|
|
.<span class="ident">with</span>(<span class="ident">token</span>(<span class="string">'i'</span>))
|
|||
|
|
.<span class="ident">parse</span>(<span class="string">"9i"</span>)
|
|||
|
|
.<span class="ident">map</span>(<span class="op">|</span><span class="ident">x</span><span class="op">|</span> <span class="ident">x</span>.<span class="number">0</span>);
|
|||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">result</span>, <span class="prelude-val">Ok</span>(<span class="string">'i'</span>));</pre>
|
|||
|
|
</div><h3 id='method.skip' class='method'><span id='skip.v' class='invisible'><code>fn <a href='#method.skip' class='fnname'>skip</a><P2>(self, p: P2) -> <a class="struct" href="../../combine/combinator/struct.Skip.html" title="struct combine::combinator::Skip">Skip</a><Self, P2> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,<br> P2: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>, </span></code></span></h3><div class='docblock'><p>Discards the value of the <code>p</code> parser and returns the value of <code>self</code>.
|
|||
|
|
Fails if any of the parsers fails.</p>
|
|||
|
|
|
|||
|
|
<pre class="rust rust-example-rendered">
|
|||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">digit</span>()
|
|||
|
|
.<span class="ident">skip</span>(<span class="ident">token</span>(<span class="string">'i'</span>))
|
|||
|
|
.<span class="ident">parse</span>(<span class="string">"9i"</span>)
|
|||
|
|
.<span class="ident">map</span>(<span class="op">|</span><span class="ident">x</span><span class="op">|</span> <span class="ident">x</span>.<span class="number">0</span>);
|
|||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">result</span>, <span class="prelude-val">Ok</span>(<span class="string">'9'</span>));</pre>
|
|||
|
|
</div><h3 id='method.and' class='method'><span id='and.v' class='invisible'><code>fn <a href='#method.and' class='fnname'>and</a><P2>(self, p: P2) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self, P2<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,<br> P2: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>, </span></code></span></h3><div class='docblock'><p>Parses with <code>self</code> followed by <code>p</code>.
|
|||
|
|
Succeeds if both parsers succeed, otherwise fails.
|
|||
|
|
Returns a tuple with both values on success.</p>
|
|||
|
|
|
|||
|
|
<pre class="rust rust-example-rendered">
|
|||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">digit</span>()
|
|||
|
|
.<span class="ident">and</span>(<span class="ident">token</span>(<span class="string">'i'</span>))
|
|||
|
|
.<span class="ident">parse</span>(<span class="string">"9i"</span>)
|
|||
|
|
.<span class="ident">map</span>(<span class="op">|</span><span class="ident">x</span><span class="op">|</span> <span class="ident">x</span>.<span class="number">0</span>);
|
|||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">result</span>, <span class="prelude-val">Ok</span>((<span class="string">'9'</span>, <span class="string">'i'</span>)));</pre>
|
|||
|
|
</div><h3 id='method.or' class='method'><span id='or.v' class='invisible'><code>fn <a href='#method.or' class='fnname'>or</a><P2>(self, p: P2) -> <a class="struct" href="../../combine/combinator/struct.Or.html" title="struct combine::combinator::Or">Or</a><Self, P2> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,<br> P2: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>, Output = Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>>, </span></code></span></h3><div class='docblock'><p>Returns a parser which attempts to parse using <code>self</code>. If <code>self</code> fails without consuming
|
|||
|
|
any input it tries to consume the same input using <code>p</code>.</p>
|
|||
|
|
<p>If you are looking to chain 3 or more parsers using <code>or</code> you may consider using the
|
|||
|
|
<a href="../macro.choice.html"><code>choice!</code></a> macro instead, which can be clearer and may result in a faster parser.</p>
|
|||
|
|
|
|||
|
|
<pre class="rust rust-example-rendered">
|
|||
|
|
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">parser</span> <span class="op">=</span> <span class="ident">string</span>(<span class="string">"let"</span>)
|
|||
|
|
.<span class="ident">or</span>(<span class="ident">digit</span>().<span class="ident">map</span>(<span class="op">|</span><span class="kw">_</span><span class="op">|</span> <span class="string">"digit"</span>))
|
|||
|
|
.<span class="ident">or</span>(<span class="ident">string</span>(<span class="string">"led"</span>));
|
|||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">parser</span>.<span class="ident">parse</span>(<span class="string">"let"</span>), <span class="prelude-val">Ok</span>((<span class="string">"let"</span>, <span class="string">""</span>)));
|
|||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">parser</span>.<span class="ident">parse</span>(<span class="string">"1"</span>), <span class="prelude-val">Ok</span>((<span class="string">"digit"</span>, <span class="string">""</span>)));
|
|||
|
|
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">parser</span>.<span class="ident">parse</span>(<span class="string">"led"</span>).<span class="ident">is_err</span>());
|
|||
|
|
|
|||
|
|
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">parser2</span> <span class="op">=</span> <span class="ident">string</span>(<span class="string">"two"</span>).<span class="ident">or</span>(<span class="ident">string</span>(<span class="string">"three"</span>));
|
|||
|
|
<span class="comment">// Fails as the parser for "two" consumes the first 't' before failing</span>
|
|||
|
|
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">parser2</span>.<span class="ident">parse</span>(<span class="string">"three"</span>).<span class="ident">is_err</span>());
|
|||
|
|
|
|||
|
|
<span class="comment">// Use 'try' to make failing parsers always act as if they have not consumed any input</span>
|
|||
|
|
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">parser3</span> <span class="op">=</span> <span class="ident">try</span>(<span class="ident">string</span>(<span class="string">"two"</span>)).<span class="ident">or</span>(<span class="ident">try</span>(<span class="ident">string</span>(<span class="string">"three"</span>)));
|
|||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">parser3</span>.<span class="ident">parse</span>(<span class="string">"three"</span>), <span class="prelude-val">Ok</span>((<span class="string">"three"</span>, <span class="string">""</span>)));</pre>
|
|||
|
|
</div><h3 id='method.then' class='method'><span id='then.v' class='invisible'><code>fn <a href='#method.then' class='fnname'>then</a><N, F>(self, f: F) -> <a class="struct" href="../../combine/combinator/struct.Then.html" title="struct combine::combinator::Then">Then</a><Self, F> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>) -> N,<br> N: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>, </span></code></span></h3><div class='docblock'><p>Parses using <code>self</code> and then passes the value to <code>f</code> which returns a parser used to parse
|
|||
|
|
the rest of the input.</p>
|
|||
|
|
|
|||
|
|
<pre class="rust rust-example-rendered">
|
|||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">digit</span>()
|
|||
|
|
.<span class="ident">then</span>(<span class="op">|</span><span class="ident">d</span><span class="op">|</span> <span class="ident">parser</span>(<span class="kw">move</span> <span class="op">|</span><span class="ident">input</span><span class="op">|</span> {
|
|||
|
|
<span class="comment">// Force input to be a &str</span>
|
|||
|
|
<span class="kw">let</span> <span class="kw">_</span>: <span class="kw-2">&</span><span class="ident">str</span> <span class="op">=</span> <span class="ident">input</span>;
|
|||
|
|
<span class="kw">if</span> <span class="ident">d</span> <span class="op">==</span> <span class="string">'9'</span> {
|
|||
|
|
<span class="prelude-val">Ok</span>((<span class="number">9</span>, <span class="ident">Consumed</span>::<span class="ident">Empty</span>(<span class="ident">input</span>)))
|
|||
|
|
}
|
|||
|
|
<span class="kw">else</span> {
|
|||
|
|
<span class="kw">let</span> <span class="ident">position</span> <span class="op">=</span> <span class="ident">input</span>.<span class="ident">position</span>();
|
|||
|
|
<span class="kw">let</span> <span class="ident">err</span> <span class="op">=</span> <span class="ident">ParseError</span>::<span class="ident">new</span>(<span class="ident">position</span>, <span class="ident">Error</span>::<span class="ident">Message</span>(<span class="string">"Not a nine"</span>.<span class="ident">into</span>()));
|
|||
|
|
<span class="prelude-val">Err</span>((<span class="ident">Consumed</span>::<span class="ident">Empty</span>(<span class="ident">err</span>)))
|
|||
|
|
}
|
|||
|
|
}))
|
|||
|
|
.<span class="ident">parse</span>(<span class="string">"9"</span>);
|
|||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">result</span>, <span class="prelude-val">Ok</span>((<span class="number">9</span>, <span class="string">""</span>)));</pre>
|
|||
|
|
</div><h3 id='method.map' class='method'><span id='map.v' class='invisible'><code>fn <a href='#method.map' class='fnname'>map</a><F, B>(self, f: F) -> <a class="struct" href="../../combine/combinator/struct.Map.html" title="struct combine::combinator::Map">Map</a><Self, F> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>) -> B, </span></code></span></h3><div class='docblock'><p>Uses <code>f</code> to map over the parsed value.</p>
|
|||
|
|
|
|||
|
|
<pre class="rust rust-example-rendered">
|
|||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">digit</span>()
|
|||
|
|
.<span class="ident">map</span>(<span class="op">|</span><span class="ident">c</span><span class="op">|</span> <span class="ident">c</span> <span class="op">==</span> <span class="string">'9'</span>)
|
|||
|
|
.<span class="ident">parse</span>(<span class="string">"9"</span>)
|
|||
|
|
.<span class="ident">map</span>(<span class="op">|</span><span class="ident">x</span><span class="op">|</span> <span class="ident">x</span>.<span class="number">0</span>);
|
|||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">result</span>, <span class="prelude-val">Ok</span>(<span class="bool-val">true</span>));</pre>
|
|||
|
|
</div><h3 id='method.flat_map' class='method'><span id='flat_map.v' class='invisible'><code>fn <a href='#method.flat_map' class='fnname'>flat_map</a><F, B>(self, f: F) -> <a class="struct" href="../../combine/combinator/struct.FlatMap.html" title="struct combine::combinator::FlatMap">FlatMap</a><Self, F> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><B, <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>>, </span></code></span></h3><div class='docblock'><p>Uses <code>f</code> to map over the output of <code>self</code>. If <code>f</code> returns an error the parser fails.</p>
|
|||
|
|
|
|||
|
|
<pre class="rust rust-example-rendered">
|
|||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">take</span>(<span class="number">4</span>)
|
|||
|
|
.<span class="ident">flat_map</span>(<span class="op">|</span><span class="ident">bs</span><span class="op">|</span> <span class="ident">many</span>(<span class="ident">digit</span>()).<span class="ident">parse</span>(<span class="ident">bs</span>).<span class="ident">map</span>(<span class="op">|</span><span class="ident">t</span><span class="op">|</span> <span class="ident">t</span>.<span class="number">0</span>))
|
|||
|
|
.<span class="ident">parse</span>(<span class="string">"12abcd"</span>);
|
|||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">result</span>, <span class="prelude-val">Ok</span>((<span class="ident">String</span>::<span class="ident">from</span>(<span class="string">"12"</span>), <span class="string">"cd"</span>)));</pre>
|
|||
|
|
</div><h3 id='method.message' class='method'><span id='message.v' class='invisible'><code>fn <a href='#method.message' class='fnname'>message</a><S>(self, msg: S) -> <a class="struct" href="../../combine/combinator/struct.Message.html" title="struct combine::combinator::Message">Message</a><Self> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,<br> S: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><<a class="enum" href="../../combine/primitives/enum.Info.html" title="enum combine::primitives::Info">Info</a><<Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a> as <a class="trait" href="../../combine/trait.StreamOnce.html" title="trait combine::StreamOnce">StreamOnce</a>>::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>, <Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a> as <a class="trait" href="../../combine/trait.StreamOnce.html" title="trait combine::StreamOnce">StreamOnce</a>>::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Range" title="type combine::StreamOnce::Range">Range</a>>>, </span></code></span></h3><div class='docblock'><p>Parses with <code>self</code> and if it fails, adds the message <code>msg</code> to the error.</p>
|
|||
|
|
|
|||
|
|
<pre class="rust rust-example-rendered">
|
|||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">token</span>(<span class="string">'9'</span>)
|
|||
|
|
.<span class="ident">message</span>(<span class="string">"Not a nine"</span>)
|
|||
|
|
.<span class="ident">parse</span>(<span class="ident">State</span>::<span class="ident">new</span>(<span class="string">"8"</span>));
|
|||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">result</span>, <span class="prelude-val">Err</span>(<span class="ident">ParseError</span> {
|
|||
|
|
<span class="ident">position</span>: <span class="op"><</span><span class="ident">char</span> <span class="kw">as</span> <span class="ident">Positioner</span><span class="op">></span>::<span class="ident">start</span>(),
|
|||
|
|
<span class="ident">errors</span>: <span class="macro">vec</span><span class="macro">!</span>[
|
|||
|
|
<span class="ident">Error</span>::<span class="ident">Unexpected</span>(<span class="string">'8'</span>.<span class="ident">into</span>()),
|
|||
|
|
<span class="ident">Error</span>::<span class="ident">Expected</span>(<span class="string">'9'</span>.<span class="ident">into</span>()),
|
|||
|
|
<span class="ident">Error</span>::<span class="ident">Message</span>(<span class="string">"Not a nine"</span>.<span class="ident">into</span>())
|
|||
|
|
]
|
|||
|
|
}));</pre>
|
|||
|
|
</div><h3 id='method.expected' class='method'><span id='expected.v' class='invisible'><code>fn <a href='#method.expected' class='fnname'>expected</a><S>(self, msg: S) -> <a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><Self> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,<br> S: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><<a class="enum" href="../../combine/primitives/enum.Info.html" title="enum combine::primitives::Info">Info</a><<Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a> as <a class="trait" href="../../combine/trait.StreamOnce.html" title="trait combine::StreamOnce">StreamOnce</a>>::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>, <Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a> as <a class="trait" href="../../combine/trait.StreamOnce.html" title="trait combine::StreamOnce">StreamOnce</a>>::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Range" title="type combine::StreamOnce::Range">Range</a>>>, </span></code></span></h3><div class='docblock'><p>Parses with <code>self</code> and if it fails without consuming any input any expected errors are
|
|||
|
|
replaced by <code>msg</code>. <code>msg</code> is then used in error messages as "Expected <code>msg</code>".</p>
|
|||
|
|
|
|||
|
|
<pre class="rust rust-example-rendered">
|
|||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">token</span>(<span class="string">'9'</span>)
|
|||
|
|
.<span class="ident">expected</span>(<span class="string">"nine"</span>)
|
|||
|
|
.<span class="ident">parse</span>(<span class="ident">State</span>::<span class="ident">new</span>(<span class="string">"8"</span>));
|
|||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">result</span>, <span class="prelude-val">Err</span>(<span class="ident">ParseError</span> {
|
|||
|
|
<span class="ident">position</span>: <span class="op"><</span><span class="ident">char</span> <span class="kw">as</span> <span class="ident">Positioner</span><span class="op">></span>::<span class="ident">start</span>(),
|
|||
|
|
<span class="ident">errors</span>: <span class="macro">vec</span><span class="macro">!</span>[<span class="ident">Error</span>::<span class="ident">Unexpected</span>(<span class="string">'8'</span>.<span class="ident">into</span>()), <span class="ident">Error</span>::<span class="ident">Expected</span>(<span class="string">"nine"</span>.<span class="ident">into</span>())]
|
|||
|
|
}));</pre>
|
|||
|
|
</div><h3 id='method.and_then' class='method'><span id='and_then.v' class='invisible'><code>fn <a href='#method.and_then' class='fnname'>and_then</a><F, O, E>(self, f: F) -> <a class="struct" href="../../combine/combinator/struct.AndThen.html" title="struct combine::combinator::AndThen">AndThen</a><Self, F> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><O, E>,<br> E: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><<a class="enum" href="../../combine/primitives/enum.Error.html" title="enum combine::primitives::Error">Error</a><<Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a> as <a class="trait" href="../../combine/trait.StreamOnce.html" title="trait combine::StreamOnce">StreamOnce</a>>::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>, <Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a> as <a class="trait" href="../../combine/trait.StreamOnce.html" title="trait combine::StreamOnce">StreamOnce</a>>::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Range" title="type combine::StreamOnce::Range">Range</a>>>, </span></code></span></h3><div class='docblock'><p>Parses with <code>self</code> and applies <code>f</code> on the result if <code>self</code> parses successfully.
|
|||
|
|
<code>f</code> may optionally fail with an error which is automatically converted to a <code>ParseError</code>.</p>
|
|||
|
|
|
|||
|
|
<pre class="rust rust-example-rendered">
|
|||
|
|
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">parser</span> <span class="op">=</span> <span class="ident">many1</span>(<span class="ident">digit</span>())
|
|||
|
|
.<span class="ident">and_then</span>(<span class="op">|</span><span class="ident">s</span>: <span class="ident">String</span><span class="op">|</span> <span class="ident">s</span>.<span class="ident">parse</span>::<span class="op"><</span><span class="ident">i32</span><span class="op">></span>());
|
|||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">parser</span>.<span class="ident">parse</span>(<span class="ident">State</span>::<span class="ident">new</span>(<span class="string">"1234"</span>)).<span class="ident">map</span>(<span class="op">|</span>(<span class="ident">x</span>, <span class="ident">state</span>)<span class="op">|</span> (<span class="ident">x</span>, <span class="ident">state</span>.<span class="ident">input</span>));
|
|||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">result</span>, <span class="prelude-val">Ok</span>((<span class="number">1234</span>, <span class="string">""</span>)));
|
|||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">parser</span>.<span class="ident">parse</span>(<span class="ident">State</span>::<span class="ident">new</span>(<span class="string">"999999999999999999999999"</span>));
|
|||
|
|
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">result</span>.<span class="ident">is_err</span>());
|
|||
|
|
<span class="comment">// Errors are report as if they occured at the start of the parse</span>
|
|||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">result</span>.<span class="ident">unwrap_err</span>().<span class="ident">position</span>, <span class="ident">SourcePosition</span> { <span class="ident">line</span>: <span class="number">1</span>, <span class="ident">column</span>: <span class="number">1</span> });</pre>
|
|||
|
|
</div><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="../../combine/combinator/struct.Iter.html" title="struct combine::combinator::Iter">Iter</a><P></span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="../../combine/combinator/struct.Iter.html" title="struct combine::combinator::Iter">Iter</a><P></h3><code class="content"><span class="where fmt-newline">impl<P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>> <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html" title="trait core::iter::iterator::Iterator">Iterator</a> for <a class="struct" href="../../combine/combinator/struct.Iter.html" title="struct combine::combinator::Iter">Iter</a><P></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code></div></div><h3 id='method.iter' class='method'><span id='iter.v' class='invisible'><code>fn <a href='#method.iter' class='fnname'>iter</a>(self, input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>) -> <a class="struct" href="../../combine/combinator/struct.Iter.html" title="struct combine::combinator::Iter">Iter</a><Self> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></code></span></h3><div class='docblock'><p>Creates an iterator from a parser and a state. Can be used as an alternative to <a href="../combinator/fn.many.html"><code>many</code></a> when
|
|||
|
|
collecting directly into a <code>FromIterator</code> type is not desirable.</p>
|
|||
|
|
|
|||
|
|
<pre class="rust rust-example-rendered">
|
|||
|
|
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buffer</span> <span class="op">=</span> <span class="ident">String</span>::<span class="ident">new</span>();
|
|||
|
|
<span class="kw">let</span> <span class="ident">number</span> <span class="op">=</span> <span class="ident">parser</span>(<span class="op">|</span><span class="ident">input</span><span class="op">|</span> {
|
|||
|
|
<span class="ident">buffer</span>.<span class="ident">clear</span>();
|
|||
|
|
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">iter</span> <span class="op">=</span> <span class="ident">digit</span>().<span class="ident">iter</span>(<span class="ident">input</span>);
|
|||
|
|
<span class="ident">buffer</span>.<span class="ident">extend</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">iter</span>);
|
|||
|
|
<span class="kw">let</span> <span class="ident">i</span> <span class="op">=</span> <span class="ident">buffer</span>.<span class="ident">parse</span>::<span class="op"><</span><span class="ident">i32</span><span class="op">></span>().<span class="ident">unwrap</span>();
|
|||
|
|
<span class="ident">iter</span>.<span class="ident">into_result</span>(<span class="ident">i</span>)
|
|||
|
|
});
|
|||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">sep_by</span>(<span class="ident">number</span>, <span class="ident">char</span>(<span class="string">','</span>))
|
|||
|
|
.<span class="ident">parse</span>(<span class="string">"123,45,6"</span>);
|
|||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">result</span>, <span class="prelude-val">Ok</span>((<span class="macro">vec</span><span class="macro">!</span>[<span class="number">123</span>, <span class="number">45</span>, <span class="number">6</span>], <span class="string">""</span>)));</pre>
|
|||
|
|
</div><h3 id='method.boxed' class='method'><span id='boxed.v' class='invisible'><code>fn <a href='#method.boxed' class='fnname'>boxed</a><'a>(<br> self<br>) -> <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html" title="struct alloc::boxed::Box">Box</a><<a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>, Output = Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>> + 'a> <span class="where fmt-newline">where<br> Self: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a> + 'a, </span></code></span></h3><div class='docblock'><p>Turns the parser into a trait object by putting it in a <code>Box</code>. Can be used to easily
|
|||
|
|
return parsers from functions without naming the type.</p>
|
|||
|
|
|
|||
|
|
<pre class="rust rust-example-rendered">
|
|||
|
|
<span class="kw">fn</span> <span class="ident">test</span><span class="op"><</span><span class="lifetime">'input</span>, <span class="ident">F</span><span class="op">></span>(<span class="ident">c</span>: <span class="ident">char</span>, <span class="ident">f</span>: <span class="ident">F</span>) <span class="op">-></span> <span class="ident">Box</span><span class="op"><</span><span class="ident">Parser</span><span class="op"><</span><span class="ident">Input</span> <span class="op">=</span> <span class="kw-2">&</span><span class="lifetime">'input</span> <span class="ident">str</span>, <span class="ident">Output</span> <span class="op">=</span> (<span class="ident">char</span>, <span class="ident">char</span>)<span class="op">>></span>
|
|||
|
|
<span class="kw">where</span> <span class="ident">F</span>: <span class="ident">FnMut</span>(<span class="ident">char</span>) <span class="op">-></span> <span class="ident">bool</span> <span class="op">+</span> <span class="lifetime">'static</span>
|
|||
|
|
{
|
|||
|
|
(<span class="ident">token</span>(<span class="ident">c</span>), <span class="ident">satisfy</span>(<span class="ident">f</span>)).<span class="ident">boxed</span>()
|
|||
|
|
}
|
|||
|
|
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">test</span>(<span class="string">'a'</span>, <span class="op">|</span><span class="ident">c</span><span class="op">|</span> <span class="ident">c</span> <span class="op">>=</span> <span class="string">'a'</span> <span class="op">&&</span> <span class="ident">c</span> <span class="op"><=</span> <span class="string">'f'</span>)
|
|||
|
|
.<span class="ident">parse</span>(<span class="string">"ac"</span>);
|
|||
|
|
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">result</span>, <span class="prelude-val">Ok</span>(((<span class="string">'a'</span>, <span class="string">'c'</span>), <span class="string">""</span>)));</pre>
|
|||
|
|
</div></div>
|
|||
|
|
<h2 id='foreign-impls' class='small-section-header'>
|
|||
|
|
Implementations on Foreign Types<a href='#foreign-impls' class='anchor'></a>
|
|||
|
|
</h2>
|
|||
|
|
<h3 id='impl-Parser' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<'a, I, O, P: ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>> <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&'a mut </a>P <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>,<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = I, Output = O>, </span></code><a href='#impl-Parser' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1824-1851' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><span class='docblock autohide'><div class='impl-items'><h4 id='associatedtype.Input-1' class="type"><span id='Input.t-1' class='invisible'><code>type <a href='#associatedtype.Input' class="type">Input</a> = I</code></span></h4>
|
|||
|
|
<h4 id='associatedtype.Output-1' class="type"><span id='Output.t-1' class='invisible'><code>type <a href='#associatedtype.Output' class="type">Output</a> = O</code></span></h4>
|
|||
|
|
<h4 id='method.parse_stream-1' class="method"><span id='parse_stream.v-1' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.parse_stream' class='fnname'>parse_stream</a>(&mut self, input: I) -> <a class="type" href="../../combine/type.ParseResult.html" title="type combine::ParseResult">ParseResult</a><O, I></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1833-1835' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse_stream_consumed-1' class="method"><span id='parse_stream_consumed.v-1' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.parse_stream_consumed' class='fnname'>parse_stream_consumed</a>(&mut self, input: I) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><O, I></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1838-1840' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse_lazy-1' class="method"><span id='parse_lazy.v-1' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.parse_lazy' class='fnname'>parse_lazy</a>(&mut self, input: I) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><O, I></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1843-1845' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.add_error-1' class="method"><span id='add_error.v-1' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.add_error' class='fnname'>add_error</a>(&mut self, error: &mut <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>)</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1848-1850' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse-1' class="method"><span id='parse.v-1' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse' class='fnname'>parse</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1396-1404' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.by_ref-1' class="method"><span id='by_ref.v-1' class='invisible'><table class='table-
|
|||
|
|
<h4 id='associatedtype.Output-2' class="type"><span id='Output.t-2' class='invisible'><code>type <a href='#associatedtype.Output' class="type">Output</a> = O</code></span></h4>
|
|||
|
|
<h4 id='method.parse_stream-2' class="method"><span id='parse_stream.v-2' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.parse_stream' class='fnname'>parse_stream</a>(&mut self, input: I) -> <a class="type" href="../../combine/type.ParseResult.html" title="type combine::ParseResult">ParseResult</a><O, I></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1861-1863' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse_stream_consumed-2' class="method"><span id='parse_stream_consumed.v-2' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.parse_stream_consumed' class='fnname'>parse_stream_consumed</a>(&mut self, input: I) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><O, I></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1866-1868' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse_lazy-2' class="method"><span id='parse_lazy.v-2' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.parse_lazy' class='fnname'>parse_lazy</a>(&mut self, input: I) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><O, I></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1871-1873' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.add_error-2' class="method"><span id='add_error.v-2' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.add_error' class='fnname'>add_error</a>(&mut self, error: &mut <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>)</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1876-1878' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse-2' class="method"><span id='parse.v-2' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse' class='fnname'>parse</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1396-1404' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.by_ref-2' class="method"><span id='by_ref.v-2' class='invisible'><table class='table-
|
|||
|
|
<h4 id='associatedtype.Output-3' class="type"><span id='Output.t-3' class='invisible'><code>type <a href='#associatedtype.Output' class="type">Output</a> = O</code></span></h4>
|
|||
|
|
<h4 id='method.parse_stream-3' class="method"><span id='parse_stream.v-3' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.parse_stream' class='fnname'>parse_stream</a>(&mut self, input: I) -> <a class="type" href="../../combine/type.ParseResult.html" title="type combine::ParseResult">ParseResult</a><O, I></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#1440-1442' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse-3' class="method"><span id='parse.v-3' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse' class='fnname'>parse</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1396-1404' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse_stream_consumed-3' class="method"><span id='parse_stream_consumed.v-3' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse_stream_consumed' class='fnname'>parse_stream_consumed</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1429-1441' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse_lazy-3' class="method"><span id='parse_lazy.v-3' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse_lazy' class='fnname'>parse_lazy</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink
|
|||
|
|
<h4 id='associatedtype.Output-4' class="type"><span id='Output.t-4' class='invisible'><code>type <a href='#associatedtype.Output' class="type">Output</a> = O</code></span></h4>
|
|||
|
|
<h4 id='method.parse_stream-4' class="method"><span id='parse_stream.v-4' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.parse_stream' class='fnname'>parse_stream</a>(&mut self, input: I) -> <a class="type" href="../../combine/type.ParseResult.html" title="type combine::ParseResult">ParseResult</a><O, I></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#1507-1509' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse-4' class="method"><span id='parse.v-4' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse' class='fnname'>parse</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1396-1404' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse_stream_consumed-4' class="method"><span id='parse_stream_consumed.v-4' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse_stream_consumed' class='fnname'>parse_stream_consumed</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1429-1441' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse_lazy-4' class="method"><span id='parse_lazy.v-4' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse_lazy' class='fnname'>parse_lazy</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink
|
|||
|
|
<h4 id='associatedtype.Output-5' class="type"><span id='Output.t-5' class='invisible'><code>type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a></code></span></h4>
|
|||
|
|
<h4 id='method.parse_lazy-5' class="method"><span id='parse_lazy.v-5' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.parse_lazy' class='fnname'>parse_lazy</a>(<br> &mut self, <br> input: Input<br>) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, Input></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2183-2231' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.add_error-5' class="method"><span id='add_error.v-5' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.add_error' class='fnname'>add_error</a>(&mut self, errors: &mut <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>)</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2232-2234' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse-5' class="method"><span id='parse.v-5' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse' class='fnname'>parse</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1396-1404' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse_stream-5' class="method"><span id='parse_stream.v-5' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse_stream' class='fnname'>parse_stream</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="type" href="../../combine/type.ParseResult.html" title="type combine::ParseResult">ParseResult</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type
|
|||
|
|
<h4 id='associatedtype.Output-6' class="type"><span id='Output.t-6' class='invisible'><code>type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, C::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a></code></span></h4>
|
|||
|
|
<h4 id='method.parse_lazy-6' class="method"><span id='parse_lazy.v-6' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.parse_lazy' class='fnname'>parse_lazy</a>(<br> &mut self, <br> input: Input<br>) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, C::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, Input></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2183-2231' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.add_error-6' class="method"><span id='add_error.v-6' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.add_error' class='fnname'>add_error</a>(&mut self, errors: &mut <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>)</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2232-2234' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse-6' class="method"><span id='parse.v-6' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse' class='fnname'>parse</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1396-1404' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse_stream-6' class="method"><span id='parse_stream.v-6' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse_stream' class='fnname'>parse_stream</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="type" href="../../combine/type.ParseResult.html" title="type combine::ParseResult">ParseResult</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type c
|
|||
|
|
<h4 id='associatedtype.Output-7' class="type"><span id='Output.t-7' class='invisible'><code>type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, C::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, D::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a></code></span></h4>
|
|||
|
|
<h4 id='method.parse_lazy-7' class="method"><span id='parse_lazy.v-7' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.parse_lazy' class='fnname'>parse_lazy</a>(<br> &mut self, <br> input: Input<br>) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, C::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, D::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, Input></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2183-2231' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.add_error-7' class="method"><span id='add_error.v-7' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.add_error' class='fnname'>add_error</a>(&mut self, errors: &mut <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>)</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2232-2234' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse-7' class="method"><span id='parse.v-7' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse' class='fnname'>parse</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1396-1404' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse_stream-7' class="method"><span id='parse_stream.v-7' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse_stream' class='fnname'>parse_stream</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="type" href="../../combine/type.ParseResult.html" title="type combine:
|
|||
|
|
<h4 id='associatedtype.Output-8' class="type"><span id='Output.t-8' class='invisible'><code>type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, C::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, D::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, E::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a></code></span></h4>
|
|||
|
|
<h4 id='method.parse_lazy-8' class="method"><span id='parse_lazy.v-8' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.parse_lazy' class='fnname'>parse_lazy</a>(<br> &mut self, <br> input: Input<br>) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, C::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, D::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, E::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, Input></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2183-2231' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.add_error-8' class="method"><span id='add_error.v-8' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.add_error' class='fnname'>add_error</a>(&mut self, errors: &mut <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>)</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2232-2234' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse-8' class="method"><span id='parse.v-8' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse' class='fnname'>parse</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1396-1404' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse_stream-8' class="method"><span id='parse_stream.v-8' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse_stream' class='fnname'>parse_stream</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="
|
|||
|
|
<h4 id='associatedtype.Output-9' class="type"><span id='Output.t-9' class='invisible'><code>type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, C::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, D::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, E::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, F::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a></code></span></h4>
|
|||
|
|
<h4 id='method.parse_lazy-9' class="method"><span id='parse_lazy.v-9' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.parse_lazy' class='fnname'>parse_lazy</a>(<br> &mut self, <br> input: Input<br>) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, C::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, D::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, E::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, F::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, Input></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2183-2231' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.add_error-9' class="method"><span id='add_error.v-9' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.add_error' class='fnname'>add_error</a>(&mut self, errors: &mut <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>)</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2232-2234' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse-9' class="method"><span id='parse.v-9' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse' class='fnname'>parse</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1396-1404' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse_stream-9' class="method"><span id='parse_stream.v-9' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse_stream' class='fnname'>parse_stream</a>(<br> &mut s
|
|||
|
|
<h4 id='associatedtype.Output-10' class="type"><span id='Output.t-10' class='invisible'><code>type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, C::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, D::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, E::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, F::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, G::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a></code></span></h4>
|
|||
|
|
<h4 id='method.parse_lazy-10' class="method"><span id='parse_lazy.v-10' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.parse_lazy' class='fnname'>parse_lazy</a>(<br> &mut self, <br> input: Input<br>) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, C::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, D::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, E::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, F::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, G::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, Input></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2183-2231' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.add_error-10' class="method"><span id='add_error.v-10' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.add_error' class='fnname'>add_error</a>(&mut self, errors: &mut <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>)</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2232-2234' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse-10' class="method"><span id='parse.v-10' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse' class='fnname'>parse</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1396-1404' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse_stream-10' class="method"><span id='parse_stream.v-10' class='invisible'><table class='table-display'><tbody><tr><td><cod
|
|||
|
|
<h4 id='associatedtype.Output-11' class="type"><span id='Output.t-11' class='invisible'><code>type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, C::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, D::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, E::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, F::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, G::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, H::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a></code></span></h4>
|
|||
|
|
<h4 id='method.parse_lazy-11' class="method"><span id='parse_lazy.v-11' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.parse_lazy' class='fnname'>parse_lazy</a>(<br> &mut self, <br> input: Input<br>) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, C::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, D::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, E::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, F::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, G::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, H::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, Input></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2183-2231' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.add_error-11' class="method"><span id='add_error.v-11' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.add_error' class='fnname'>add_error</a>(&mut self, errors: &mut <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>)</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2232-2234' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse-11' class="method"><span id='parse.v-11' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse' class='fnname'>parse</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/primitives.rs.html#1396-1404' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='metho
|
|||
|
|
<h4 id='associatedtype.Output-12' class="type"><span id='Output.t-12' class='invisible'><code>type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, C::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, D::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, E::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, F::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, G::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, H::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, I::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a></code></span></h4>
|
|||
|
|
<h4 id='method.parse_lazy-12' class="method"><span id='parse_lazy.v-12' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.parse_lazy' class='fnname'>parse_lazy</a>(<br> &mut self, <br> input: Input<br>) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, C::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, D::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, E::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, F::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, G::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, H::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, I::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, Input></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2183-2231' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.add_error-12' class="method"><span id='add_error.v-12' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.add_error' class='fnname'>add_error</a>(&mut self, errors: &mut <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>)</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2232-2234' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse-12' class="method"><span id='parse.v-12' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse' class='fnname'>parse</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../.
|
|||
|
|
<h4 id='associatedtype.Output-13' class="type"><span id='Output.t-13' class='invisible'><code>type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, C::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, D::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, E::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, F::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, G::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, H::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, I::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, J::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a></code></span></h4>
|
|||
|
|
<h4 id='method.parse_lazy-13' class="method"><span id='parse_lazy.v-13' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.parse_lazy' class='fnname'>parse_lazy</a>(<br> &mut self, <br> input: Input<br>) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, C::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, D::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, E::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, F::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, G::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, H::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, I::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, J::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, Input></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2183-2231' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.add_error-13' class="method"><span id='add_error.v-13' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.add_error' class='fnname'>add_error</a>(&mut self, errors: &mut <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>)</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2232-2234' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse-13' class="method"><span id='parse.v-13' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse' class='fnname'>parse</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser
|
|||
|
|
<h4 id='associatedtype.Output-14' class="type"><span id='Output.t-14' class='invisible'><code>type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, C::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, D::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, E::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, F::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, G::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, H::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, I::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, J::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, K::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a></code></span></h4>
|
|||
|
|
<h4 id='method.parse_lazy-14' class="method"><span id='parse_lazy.v-14' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.parse_lazy' class='fnname'>parse_lazy</a>(<br> &mut self, <br> input: Input<br>) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, C::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, D::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, E::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, F::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, G::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, H::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, I::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, J::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, K::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, Input></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2183-2231' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.add_error-14' class="method"><span id='add_error.v-14' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.add_error' class='fnname'>add_error</a>(&mut self, errors: &mut <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>)</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2232-2234' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse-14' class="method"><span id='parse.v-14' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse' class='fnname'>parse</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError
|
|||
|
|
<h4 id='associatedtype.Output-15' class="type"><span id='Output.t-15' class='invisible'><code>type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, C::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, D::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, E::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, F::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, G::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, H::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, I::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, J::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, K::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, L::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a></code></span></h4>
|
|||
|
|
<h4 id='method.parse_lazy-15' class="method"><span id='parse_lazy.v-15' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.parse_lazy' class='fnname'>parse_lazy</a>(<br> &mut self, <br> input: Input<br>) -> <a class="type" href="../../combine/type.ConsumedResult.html" title="type combine::ConsumedResult">ConsumedResult</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>A::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, B::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, C::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, D::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, E::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, F::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, G::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, H::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, I::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, J::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, K::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, L::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a>, Input></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2183-2231' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.add_error-15' class="method"><span id='add_error.v-15' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='#method.add_error' class='fnname'>add_error</a>(&mut self, errors: &mut <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>)</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/combine/combinator.rs.html#2232-2234' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><h4 id='method.parse-15' class="method"><span id='parse.v-15' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../combine/trait.Parser.html#method.parse' class='fnname'>parse</a>(<br> &mut self, <br> input: Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><br>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a>Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, Self::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.ht
|
|||
|
|
<h2 id='implementors' class='small-section-header'>
|
|||
|
|
Implementors<a href='#implementors' class='anchor'></a>
|
|||
|
|
</h2>
|
|||
|
|
<ul class='item-list' id='implementors-list'>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for <a class="struct" href="../../combine/combinator/struct.Any.html" title="struct combine::combinator::Any">Any</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#38-52' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I, P> Parser for <a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, P> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>,<br> P: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#99-114' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I, P, R> Parser for <a class="struct" href="../../combine/combinator/struct.SatisfyMap.html" title="struct combine::combinator::SatisfyMap">SatisfyMap</a><I, P> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>,<br> P: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><R>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = R;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#145-156' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for <a class="struct" href="../../combine/combinator/struct.Token.html" title="struct combine::combinator::Token">Token</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>,<br> I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a> + <a class="trait" href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#204-220' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<C, T, I> Parser for <a class="struct" href="../../combine/combinator/struct.Tokens.html" title="struct combine::combinator::Tokens">Tokens</a><C, T, I> <span class="where fmt-newline">where<br> C: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(T::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html#associatedtype.Item" title="type core::iter::traits::IntoIterator::Item">Item</a>, I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>,<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html" title="trait core::iter::traits::IntoIterator">IntoIterator</a>,<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = T;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#257-308' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for <a class="struct" href="../../combine/combinator/struct.Position.html" title="struct combine::combinator::Position">Position</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Position" title="type combine::StreamOnce::Position">Position</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#356-367' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I, O, S, P> Parser for <a class="struct" href="../../combine/combinator/struct.Choice.html" title="struct combine::combinator::Choice">Choice</a><S, P> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>,<br> S: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.AsMut.html" title="trait core::convert::AsMut">AsMut</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">[</a>P<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>>,<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = I, Output = O>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = O;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#397-433' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<T, I> Parser for <a class="struct" href="../../combine/combinator/struct.OneOf.html" title="struct combine::combinator::OneOf">OneOf</a><T, I> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html" title="trait core::iter::traits::IntoIterator">IntoIterator</a><Item = I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>>,<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>,<br> I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#444-463' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<T, I> Parser for <a class="struct" href="../../combine/combinator/struct.NoneOf.html" title="struct combine::combinator::NoneOf">NoneOf</a><T, I> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> + <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.IntoIterator.html" title="trait core::iter::traits::IntoIterator">IntoIterator</a><Item = I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>>,<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>,<br> I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#499-512' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<P, F> Parser for <a class="struct" href="../../combine/combinator/struct.Count.html" title="struct combine::combinator::Count">Count</a><F, P> <span class="where fmt-newline">where<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.FromIterator.html" title="trait core::iter::traits::FromIterator">FromIterator</a><P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = F;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#555-573' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<P, F> Parser for <a class="struct" href="../../combine/combinator/struct.CountMinMax.html" title="struct combine::combinator::CountMinMax">CountMinMax</a><F, P> <span class="where fmt-newline">where<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.FromIterator.html" title="trait core::iter::traits::FromIterator">FromIterator</a><P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = F;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#635-659' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for <a class="struct" href="../../combine/combinator/struct.Unexpected.html" title="struct combine::combinator::Unexpected">Unexpected</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#794-807' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I, T> Parser for <a class="struct" href="../../combine/combinator/struct.Value.html" title="struct combine::combinator::Value">Value</a><I, T> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>,<br> T: <a class="trait" href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = T;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#833-844' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for <a class="struct" href="../../combine/combinator/struct.Eof.html" title="struct combine::combinator::Eof">Eof</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#900-918' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<F, P> Parser for <a class="struct" href="../../combine/combinator/struct.Many.html" title="struct combine::combinator::Many">Many</a><F, P> <span class="where fmt-newline">where<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.FromIterator.html" title="trait core::iter::traits::FromIterator">FromIterator</a><P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = F;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#1018-1030' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<F, P> Parser for <a class="struct" href="../../combine/combinator/struct.Many1.html" title="struct combine::combinator::Many1">Many1</a><F, P> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.FromIterator.html" title="trait core::iter::traits::FromIterator">FromIterator</a><P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>>,<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = F;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#1061-1083' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<P> Parser for <a class="struct" href="../../combine/combinator/struct.SkipMany.html" title="struct combine::combinator::SkipMany">SkipMany</a><P> <span class="where fmt-newline">where<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = <P as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Map.html" title="struct combine::combinator::Map">Map</a><<a class="struct" href="../../combine/combinator/struct.Many.html" title="struct combine::combinator::Many">Many</a><<a class="struct" href="https://doc.rust-lang.org/nightly/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>>, <a class="struct" href="../../combine/combinator/struct.Map.html" title="struct combine::combinator::Map">Map</a><P, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>)>>, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>>)> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#12-31' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<P> Parser for <a class="struct" href="../../combine/combinator/struct.SkipMany1.html" title="struct combine::combinator::SkipMany1">SkipMany1</a><P> <span class="where fmt-newline">where<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = <P as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Map.html" title="struct combine::combinator::Map">Map</a><<a class="struct" href="../../combine/combinator/struct.Many1.html" title="struct combine::combinator::Many1">Many1</a><<a class="struct" href="https://doc.rust-lang.org/nightly/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>>, <a class="struct" href="../../combine/combinator/struct.Map.html" title="struct combine::combinator::Map">Map</a><P, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>)>>, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a><<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>>)> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#12-31' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<F, P, S> Parser for <a class="struct" href="../../combine/combinator/struct.SepBy.html" title="struct combine::combinator::SepBy">SepBy</a><F, P, S> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.FromIterator.html" title="trait core::iter::traits::FromIterator">FromIterator</a><P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>>,<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>,<br> S: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = F;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#1167-1188' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<F, P, S> Parser for <a class="struct" href="../../combine/combinator/struct.SepBy1.html" title="struct combine::combinator::SepBy1">SepBy1</a><F, P, S> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.FromIterator.html" title="trait core::iter::traits::FromIterator">FromIterator</a><P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>>,<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>,<br> S: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = F;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#1229-1253' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<F, P, S> Parser for <a class="struct" href="../../combine/combinator/struct.SepEndBy.html" title="struct combine::combinator::SepEndBy">SepEndBy</a><F, P, S> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.FromIterator.html" title="trait core::iter::traits::FromIterator">FromIterator</a><P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>>,<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>,<br> S: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = F;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#1303-1324' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<F, P, S> Parser for <a class="struct" href="../../combine/combinator/struct.SepEndBy1.html" title="struct combine::combinator::SepEndBy1">SepEndBy1</a><F, P, S> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.FromIterator.html" title="trait core::iter::traits::FromIterator">FromIterator</a><P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>>,<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>,<br> S: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = F;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#1366-1394' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I, O, F> Parser for <a class="struct" href="../../combine/combinator/struct.FnParser.html" title="struct combine::combinator::FnParser">FnParser</a><I, F> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(I) -> <a class="type" href="../../combine/type.ParseResult.html" title="type combine::ParseResult">ParseResult</a><O, I>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = O;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#1489-1499' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<P> Parser for <a class="struct" href="../../combine/combinator/struct.Optional.html" title="struct combine::combinator::Optional">Optional</a><P> <span class="where fmt-newline">where<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a><P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#1514-1529' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<L, R, P> Parser for <a class="struct" href="../../combine/combinator/struct.Between.html" title="struct combine::combinator::Between">Between</a><L, R, P> <span class="where fmt-newline">where<br> L: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>,<br> R: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = <L as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>,<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = <L as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = <L as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Skip.html" title="struct combine::combinator::Skip">Skip</a><<a class="struct" href="../../combine/combinator/struct.With.html" title="struct combine::combinator::With">With</a><L, P>, R> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#12-31' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I, P, Op> Parser for <a class="struct" href="../../combine/combinator/struct.Chainl1.html" title="struct combine::combinator::Chainl1">Chainl1</a><P, Op> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>,<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = I>,<br> Op: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = I>,<br> Op::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>) -> P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#1581-1613' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I, P, Op> Parser for <a class="struct" href="../../combine/combinator/struct.Chainr1.html" title="struct combine::combinator::Chainr1">Chainr1</a><P, Op> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>,<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = I>,<br> Op: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = I>,<br> Op::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>) -> P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#1641-1677' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I, O, P> Parser for <a class="struct" href="../../combine/combinator/struct.Try.html" title="struct combine::combinator::Try">Try</a><P> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>,<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = I, Output = O>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = O;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#1705-1716' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I, O, P> Parser for <a class="struct" href="../../combine/combinator/struct.LookAhead.html" title="struct combine::combinator::LookAhead">LookAhead</a><P> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>,<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = I, Output = O>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = O;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#1745-1762' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I, P1, P2> Parser for <a class="struct" href="../../combine/combinator/struct.With.html" title="struct combine::combinator::With">With</a><P1, P2> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>,<br> P1: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = I>,<br> P2: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = I>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = P2::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#1793-1808' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I, P1, P2> Parser for <a class="struct" href="../../combine/combinator/struct.Skip.html" title="struct combine::combinator::Skip">Skip</a><P1, P2> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>,<br> P1: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = I>,<br> P2: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = I>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = P1::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#1827-1842' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I, P> Parser for <a class="struct" href="../../combine/combinator/struct.Message.html" title="struct combine::combinator::Message">Message</a><P> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>,<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = I>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#1860-1889' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I, O, P1, P2> Parser for <a class="struct" href="../../combine/combinator/struct.Or.html" title="struct combine::combinator::Or">Or</a><P1, P2> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>,<br> P1: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = I, Output = O>,<br> P2: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = I, Output = O>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = O;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#1910-1936' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I, A, B, P, F> Parser for <a class="struct" href="../../combine/combinator/struct.Map.html" title="struct combine::combinator::Map">Map</a><P, F> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>,<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = I, Output = A>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(A) -> B, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = B;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#1955-1975' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I, A, B, P, F> Parser for <a class="struct" href="../../combine/combinator/struct.FlatMap.html" title="struct combine::combinator::FlatMap">FlatMap</a><P, F> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>,<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = I, Output = A>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(A) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><B, <a class="struct" href="../../combine/primitives/struct.ParseError.html" title="struct combine::primitives::ParseError">ParseError</a><I>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = B;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#1991-2017' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<P, N, F> Parser for <a class="struct" href="../../combine/combinator/struct.Then.html" title="struct combine::combinator::Then">Then</a><P, F> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>) -> N,<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>,<br> N: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a><Input = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = N::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = N::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#2033-2062' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<P> Parser for <a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><P> <span class="where fmt-newline">where<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#2084-2113' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<P, F, O, E> Parser for <a class="struct" href="../../combine/combinator/struct.AndThen.html" title="struct combine::combinator::AndThen">AndThen</a><P, F> <span class="where fmt-newline">where<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>) -> <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a><O, E>,<br> E: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><<a class="enum" href="../../combine/primitives/enum.Error.html" title="enum combine::primitives::Error">Error</a><<P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a> as <a class="trait" href="../../combine/trait.StreamOnce.html" title="trait combine::StreamOnce">StreamOnce</a>>::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>, <P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a> as <a class="trait" href="../../combine/trait.StreamOnce.html" title="trait combine::StreamOnce">StreamOnce</a>>::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Range" title="type combine::StreamOnce::Range">Range</a>>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = O;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#2131-2158' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<E, I, O> Parser for <a class="struct" href="../../combine/combinator/struct.EnvParser.html" title="struct combine::combinator::EnvParser">EnvParser</a><E, I, O> <span class="where fmt-newline">where<br> E: <a class="trait" href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>,<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = O;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#2379-2391' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<P, F> Parser for <a class="struct" href="../../combine/combinator/struct.Recognize.html" title="struct combine::combinator::Recognize">Recognize</a><F, P> <span class="where fmt-newline">where<br> P: <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/trait.FromIterator.html" title="trait core::iter::traits::FromIterator">FromIterator</a><<P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a> as <a class="trait" href="../../combine/trait.StreamOnce.html" title="trait combine::StreamOnce">StreamOnce</a>>::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = P::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Input" title="type combine::Parser::Input">Input</a>;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = F;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/combinator.rs.html#2443-2489' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for <a class="struct" href="../../combine/range/struct.Range.html" title="struct combine::range::Range">Range</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/primitives/trait.RangeStream.html" title="trait combine::primitives::RangeStream">RangeStream</a>,<br> I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Range" title="type combine::StreamOnce::Range">Range</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a> + <a class="trait" href="../../combine/primitives/trait.Range.html" title="trait combine::primitives::Range">Range</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Range" title="type combine::StreamOnce::Range">Range</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/range.rs.html#10-35' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for <a class="struct" href="../../combine/range/struct.Take.html" title="struct combine::range::Take">Take</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/primitives/trait.RangeStream.html" title="trait combine::primitives::RangeStream">RangeStream</a>,<br> I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Range" title="type combine::StreamOnce::Range">Range</a>: <a class="trait" href="../../combine/primitives/trait.Range.html" title="trait combine::primitives::Range">Range</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Range" title="type combine::StreamOnce::Range">Range</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/range.rs.html#62-78' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I, F> Parser for <a class="struct" href="../../combine/range/struct.TakeWhile.html" title="struct combine::range::TakeWhile">TakeWhile</a><I, F> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/primitives/trait.RangeStream.html" title="trait combine::primitives::RangeStream">RangeStream</a>,<br> I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Range" title="type combine::StreamOnce::Range">Range</a>: <a class="trait" href="../../combine/primitives/trait.Range.html" title="trait combine::primitives::Range">Range</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Range" title="type combine::StreamOnce::Range">Range</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/range.rs.html#107-120' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I, F> Parser for <a class="struct" href="../../combine/range/struct.TakeWhile1.html" title="struct combine::range::TakeWhile1">TakeWhile1</a><I, F> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/primitives/trait.RangeStream.html" title="trait combine::primitives::RangeStream">RangeStream</a>,<br> I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Range" title="type combine::StreamOnce::Range">Range</a>: <a class="trait" href="../../combine/primitives/trait.Range.html" title="trait combine::primitives::Range">Range</a>,<br> F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Item" title="type combine::StreamOnce::Item">Item</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Range" title="type combine::StreamOnce::Range">Range</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/range.rs.html#146-167' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for <a class="struct" href="../../combine/range/struct.TakeUntilRange.html" title="struct combine::range::TakeUntilRange">TakeUntilRange</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/primitives/trait.RangeStream.html" title="trait combine::primitives::RangeStream">RangeStream</a>,<br> I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Range" title="type combine::StreamOnce::Range">Range</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a> + <a class="trait" href="../../combine/primitives/trait.Range.html" title="trait combine::primitives::Range">Range</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = I::<a class="type" href="../../combine/trait.StreamOnce.html#associatedtype.Range" title="type combine::StreamOnce::Range">Range</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/range.rs.html#196-238' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<'a, B, I> Parser for <a class="struct" href="../../combine/byte/num/struct.U16.html" title="struct combine::byte::num::U16">U16</a><B, I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/primitives/trait.RangeStream.html" title="trait combine::primitives::RangeStream">RangeStream</a><Range = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&'a [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>>,<br> B: <a class="trait" href="../../byteorder/trait.ByteOrder.html" title="trait byteorder::ByteOrder">ByteOrder</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u16.html">u16</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/byte.rs.html#383-398' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<'a, B, I> Parser for <a class="struct" href="../../combine/byte/num/struct.U32.html" title="struct combine::byte::num::U32">U32</a><B, I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/primitives/trait.RangeStream.html" title="trait combine::primitives::RangeStream">RangeStream</a><Range = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&'a [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>>,<br> B: <a class="trait" href="../../byteorder/trait.ByteOrder.html" title="trait byteorder::ByteOrder">ByteOrder</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/byte.rs.html#383-398' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<'a, B, I> Parser for <a class="struct" href="../../combine/byte/num/struct.U64.html" title="struct combine::byte::num::U64">U64</a><B, I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/primitives/trait.RangeStream.html" title="trait combine::primitives::RangeStream">RangeStream</a><Range = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&'a [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>>,<br> B: <a class="trait" href="../../byteorder/trait.ByteOrder.html" title="trait byteorder::ByteOrder">ByteOrder</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/byte.rs.html#383-398' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<'a, B, I> Parser for <a class="struct" href="../../combine/byte/num/struct.I16.html" title="struct combine::byte::num::I16">I16</a><B, I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/primitives/trait.RangeStream.html" title="trait combine::primitives::RangeStream">RangeStream</a><Range = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&'a [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>>,<br> B: <a class="trait" href="../../byteorder/trait.ByteOrder.html" title="trait byteorder::ByteOrder">ByteOrder</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i16.html">i16</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/byte.rs.html#383-398' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<'a, B, I> Parser for <a class="struct" href="../../combine/byte/num/struct.I32.html" title="struct combine::byte::num::I32">I32</a><B, I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/primitives/trait.RangeStream.html" title="trait combine::primitives::RangeStream">RangeStream</a><Range = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&'a [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>>,<br> B: <a class="trait" href="../../byteorder/trait.ByteOrder.html" title="trait byteorder::ByteOrder">ByteOrder</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i32.html">i32</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/byte.rs.html#383-398' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<'a, B, I> Parser for <a class="struct" href="../../combine/byte/num/struct.I64.html" title="struct combine::byte::num::I64">I64</a><B, I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/primitives/trait.RangeStream.html" title="trait combine::primitives::RangeStream">RangeStream</a><Range = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&'a [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>>,<br> B: <a class="trait" href="../../byteorder/trait.ByteOrder.html" title="trait byteorder::ByteOrder">ByteOrder</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.i64.html">i64</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/byte.rs.html#383-398' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<'a, B, I> Parser for <a class="struct" href="../../combine/byte/num/struct.F32.html" title="struct combine::byte::num::F32">F32</a><B, I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/primitives/trait.RangeStream.html" title="trait combine::primitives::RangeStream">RangeStream</a><Range = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&'a [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>>,<br> B: <a class="trait" href="../../byteorder/trait.ByteOrder.html" title="trait byteorder::ByteOrder">ByteOrder</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f32.html">f32</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/byte.rs.html#383-398' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<'a, B, I> Parser for <a class="struct" href="../../combine/byte/num/struct.F64.html" title="struct combine::byte::num::F64">F64</a><B, I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/primitives/trait.RangeStream.html" title="trait combine::primitives::RangeStream">RangeStream</a><Range = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&'a [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>>,<br> B: <a class="trait" href="../../byteorder/trait.ByteOrder.html" title="trait byteorder::ByteOrder">ByteOrder</a>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.f64.html">f64</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/byte.rs.html#383-398' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::byte::<a class="struct" href="../../combine/byte/struct.Digit.html" title="struct combine::byte::Digit">Digit</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::byte::<a class="struct" href="../../combine/byte/struct.Space.html" title="struct combine::byte::Space">Space</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::byte::<a class="struct" href="../../combine/byte/struct.Spaces.html" title="struct combine::byte::Spaces">Spaces</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.SkipMany.html" title="struct combine::combinator::SkipMany">SkipMany</a><<a class="struct" href="../../combine/byte/struct.Space.html" title="struct combine::byte::Space">Space</a><I>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::byte::<a class="struct" href="../../combine/byte/struct.Newline.html" title="struct combine::byte::Newline">Newline</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::byte::<a class="struct" href="../../combine/byte/struct.CrLf.html" title="struct combine::byte::CrLf">CrLf</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.With.html" title="struct combine::combinator::With">With</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>, <a class="struct" href="../../combine/byte/struct.Newline.html" title="struct combine::byte::Newline">Newline</a><I>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::byte::<a class="struct" href="../../combine/byte/struct.Tab.html" title="struct combine::byte::Tab">Tab</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::byte::<a class="struct" href="../../combine/byte/struct.Upper.html" title="struct combine::byte::Upper">Upper</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::byte::<a class="struct" href="../../combine/byte/struct.Lower.html" title="struct combine::byte::Lower">Lower</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::byte::<a class="struct" href="../../combine/byte/struct.AlphaNum.html" title="struct combine::byte::AlphaNum">AlphaNum</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::byte::<a class="struct" href="../../combine/byte/struct.Letter.html" title="struct combine::byte::Letter">Letter</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::byte::<a class="struct" href="../../combine/byte/struct.OctDigit.html" title="struct combine::byte::OctDigit">OctDigit</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::byte::<a class="struct" href="../../combine/byte/struct.HexDigit.html" title="struct combine::byte::HexDigit">HexDigit</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<'a, I> Parser for <a class="struct" href="../../combine/byte/struct.Bytes.html" title="struct combine::byte::Bytes">Bytes</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>, Range = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&'a [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&'static [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/byte.rs.html#272-287' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<'a, C, I> Parser for <a class="struct" href="../../combine/byte/struct.BytesCmp.html" title="struct combine::byte::BytesCmp">BytesCmp</a><C, I> <span class="where fmt-newline">where<br> C: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>,<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>, Range = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&'a [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&'static [</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/byte.rs.html#321-337' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::char::<a class="struct" href="../../combine/char/struct.Digit.html" title="struct combine::char::Digit">Digit</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#428-449' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::char::<a class="struct" href="../../combine/char/struct.Space.html" title="struct combine::char::Space">Space</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::char::<a class="struct" href="../../combine/char/struct.Spaces.html" title="struct combine::char::Spaces">Spaces</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.SkipMany.html" title="struct combine::combinator::SkipMany">SkipMany</a><<a class="struct" href="../../combine/char/struct.Space.html" title="struct combine::char::Space">Space</a><I>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::char::<a class="struct" href="../../combine/char/struct.Newline.html" title="struct combine::char::Newline">Newline</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::char::<a class="struct" href="../../combine/char/struct.CrLf.html" title="struct combine::char::CrLf">CrLf</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.With.html" title="struct combine::combinator::With">With</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>, <a class="struct" href="../../combine/char/struct.Newline.html" title="struct combine::char::Newline">Newline</a><I>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::char::<a class="struct" href="../../combine/char/struct.Tab.html" title="struct combine::char::Tab">Tab</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::char::<a class="struct" href="../../combine/char/struct.Upper.html" title="struct combine::char::Upper">Upper</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::char::<a class="struct" href="../../combine/char/struct.Lower.html" title="struct combine::char::Lower">Lower</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::char::<a class="struct" href="../../combine/char/struct.AlphaNum.html" title="struct combine::char::AlphaNum">AlphaNum</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::char::<a class="struct" href="../../combine/char/struct.Letter.html" title="struct combine::char::Letter">Letter</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::char::<a class="struct" href="../../combine/char/struct.OctDigit.html" title="struct combine::char::OctDigit">OctDigit</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for combine::char::<a class="struct" href="../../combine/char/struct.HexDigit.html" title="struct combine::char::HexDigit">HexDigit</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = <<a class="struct" href="../../combine/combinator/struct.Expected.html" title="struct combine::combinator::Expected">Expected</a><<a class="struct" href="../../combine/combinator/struct.Satisfy.html" title="struct combine::combinator::Satisfy">Satisfy</a><I, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.fn.html">fn</a>(_: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>>> as <a class="trait" href="../../combine/trait.Parser.html" title="trait combine::Parser">Parser</a>>::<a class="type" href="../../combine/trait.Parser.html#associatedtype.Output" title="type combine::Parser::Output">Output</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/lib.rs.html#189-201' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<I> Parser for <a class="struct" href="../../combine/char/struct.Str.html" title="struct combine::char::Str">Str</a><I> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = &'static <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.str.html">str</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/char.rs.html#299-314' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
<li><table class='table-display'><tbody><tr><td><code>impl<C, I> Parser for <a class="struct" href="../../combine/char/struct.StrCmp.html" title="struct combine::char::StrCmp">StrCmp</a><C, I> <span class="where fmt-newline">where<br> C: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>) -> <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>,<br> I: <a class="trait" href="../../combine/trait.Stream.html" title="trait combine::Stream">Stream</a><Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.char.html">char</a>>, </span><span class="where fmt-newline"> type <a href='#associatedtype.Input' class="type">Input</a> = I;</span><span class="where fmt-newline"> type <a href='#associatedtype.Output' class="type">Output</a> = &'static <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.str.html">str</a>;</span></code><td><div class='out-of-band'><a class='srclink' href='../../src/combine/char.rs.html#341-357' title='goto source code'>[src]</a></div></td></tr></tbody></table></li>
|
|||
|
|
</ul><script type="text/javascript">window.inlined_types=new Set([]);</script><script type="text/javascript" async
|
|||
|
|
src="../../implementors/combine/primitives/trait.Parser.js">
|
|||
|
|
</script></section>
|
|||
|
|
<section id='search' class="content hidden"></section>
|
|||
|
|
|
|||
|
|
<section class="footer"></section>
|
|||
|
|
|
|||
|
|
<aside id="help" class="hidden">
|
|||
|
|
<div>
|
|||
|
|
<h1 class="hidden">Help</h1>
|
|||
|
|
|
|||
|
|
<div class="shortcuts">
|
|||
|
|
<h2>Keyboard Shortcuts</h2>
|
|||
|
|
|
|||
|
|
<dl>
|
|||
|
|
<dt><kbd>?</kbd></dt>
|
|||
|
|
<dd>Show this help dialog</dd>
|
|||
|
|
<dt><kbd>S</kbd></dt>
|
|||
|
|
<dd>Focus the search field</dd>
|
|||
|
|
<dt><kbd>↑</kbd></dt>
|
|||
|
|
<dd>Move up in search results</dd>
|
|||
|
|
<dt><kbd>↓</kbd></dt>
|
|||
|
|
<dd>Move down in search results</dd>
|
|||
|
|
<dt><kbd>↹</kbd></dt>
|
|||
|
|
<dd>Switch tab</dd>
|
|||
|
|
<dt><kbd>⏎</kbd></dt>
|
|||
|
|
<dd>Go to active search result</dd>
|
|||
|
|
<dt><kbd>+</kbd></dt>
|
|||
|
|
<dd>Expand all sections</dd>
|
|||
|
|
<dt><kbd>-</kbd></dt>
|
|||
|
|
<dd>Collapse all sections</dd>
|
|||
|
|
</dl>
|
|||
|
|
</div>
|
|||
|
|
|
|||
|
|
<div class="infos">
|
|||
|
|
<h2>Search Tricks</h2>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
Prefix searches with a type followed by a colon (e.g.
|
|||
|
|
<code>fn:</code>) to restrict the search to a given type.
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
Accepted types are: <code>fn</code>, <code>mod</code>,
|
|||
|
|
<code>struct</code>, <code>enum</code>,
|
|||
|
|
<code>trait</code>, <code>type</code>, <code>macro</code>,
|
|||
|
|
and <code>const</code>.
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
Search functions by type signature (e.g.
|
|||
|
|
<code>vec -> usize</code> or <code>* -> vec</code>)
|
|||
|
|
</p>
|
|||
|
|
</div>
|
|||
|
|
</div>
|
|||
|
|
</aside>
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
<script>
|
|||
|
|
window.rootPath = "../../";
|
|||
|
|
window.currentCrate = "combine";
|
|||
|
|
</script>
|
|||
|
|
<script src="../../main.js"></script>
|
|||
|
|
<script defer src="../../search-index.js"></script>
|
|||
|
|
</body>
|
|||
|
|
</html>
|