pub struct SeparatedBy<A, B, U> { /* private fields */ }
Expand description
See Parser::separated_by
.
Implementations§
Source§impl<A, B, U> SeparatedBy<A, B, U>
impl<A, B, U> SeparatedBy<A, B, U>
Sourcepub fn allow_leading(self) -> Self
pub fn allow_leading(self) -> Self
Allow a leading separator to appear before the first item.
Note that even if no items are parsed, a leading separator is permitted.
§Examples
let r#enum = text::keyword::<_, _, Simple<char>>("enum")
.padded()
.ignore_then(text::ident()
.padded()
.separated_by(just('|'))
.allow_leading());
assert_eq!(r#enum.parse("enum True | False"), Ok(vec!["True".to_string(), "False".to_string()]));
assert_eq!(r#enum.parse("
enum
| True
| False
"), Ok(vec!["True".to_string(), "False".to_string()]));
Sourcepub fn allow_trailing(self) -> Self
pub fn allow_trailing(self) -> Self
Allow a trailing separator to appear after the last item.
Note that if no items are parsed, no leading separator is permitted.
§Examples
let numbers = text::int::<_, Simple<char>>(10)
.padded()
.separated_by(just(','))
.allow_trailing()
.delimited_by(just('('), just(')'));
assert_eq!(numbers.parse("(1, 2)"), Ok(vec!["1".to_string(), "2".to_string()]));
assert_eq!(numbers.parse("(1, 2,)"), Ok(vec!["1".to_string(), "2".to_string()]));
Sourcepub fn at_least(self, n: usize) -> Self
pub fn at_least(self, n: usize) -> Self
Require that the pattern appear at least a minimum number of times.
let numbers = just::<_, _, Simple<char>>('-')
.separated_by(just('.'))
.at_least(2);
assert!(numbers.parse("").is_err());
assert!(numbers.parse("-").is_err());
assert_eq!(numbers.parse("-.-"), Ok(vec!['-', '-']));
Sourcepub fn at_most(self, n: usize) -> Self
pub fn at_most(self, n: usize) -> Self
Require that the pattern appear at most a maximum number of times.
let row_4 = text::int::<_, Simple<char>>(10)
.padded()
.separated_by(just(','))
.at_most(4);
let matrix_4x4 = row_4
.separated_by(just(','))
.at_most(4);
assert_eq!(
matrix_4x4.parse("0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15"),
Ok(vec![
vec!["0".to_string(), "1".to_string(), "2".to_string(), "3".to_string()],
vec!["4".to_string(), "5".to_string(), "6".to_string(), "7".to_string()],
vec!["8".to_string(), "9".to_string(), "10".to_string(), "11".to_string()],
vec!["12".to_string(), "13".to_string(), "14".to_string(), "15".to_string()],
]),
);
Sourcepub fn exactly(self, n: usize) -> Self
pub fn exactly(self, n: usize) -> Self
Require that the pattern appear exactly the given number of times.
let coordinate_3d = text::int::<_, Simple<char>>(10)
.padded()
.separated_by(just(','))
.exactly(3)
.then_ignore(end());
// Not enough elements
assert!(coordinate_3d.parse("4, 3").is_err());
// Too many elements
assert!(coordinate_3d.parse("7, 2, 13, 4").is_err());
// Just the right number of elements
assert_eq!(coordinate_3d.parse("5, 0, 12"), Ok(vec!["5".to_string(), "0".to_string(), "12".to_string()]));
Trait Implementations§
Source§impl<I: Clone, O, U, A: Parser<I, O, Error = E>, B: Parser<I, U, Error = E>, E: Error<I>> Parser<I, Vec<O>> for SeparatedBy<A, B, U>
impl<I: Clone, O, U, A: Parser<I, O, Error = E>, B: Parser<I, U, Error = E>, E: Error<I>> Parser<I, Vec<O>> for SeparatedBy<A, B, U>
Source§fn parse_recovery<'a, Iter, S>(
&self,
stream: S,
) -> (Option<O>, Vec<Self::Error>)
fn parse_recovery<'a, Iter, S>( &self, stream: S, ) -> (Option<O>, Vec<Self::Error>)
Parse a stream of tokens, yielding an output if possible, and any errors encountered along the way. Read more
Source§fn parse_recovery_verbose<'a, Iter, S>(
&self,
stream: S,
) -> (Option<O>, Vec<Self::Error>)
fn parse_recovery_verbose<'a, Iter, S>( &self, stream: S, ) -> (Option<O>, Vec<Self::Error>)
Parse a stream of tokens, yielding an output if possible, and any errors encountered along the way. Unlike
Parser::parse_recovery
, this function will produce verbose debugging output as it executes. Read moreSource§fn parse<'a, Iter, S>(&self, stream: S) -> Result<O, Vec<Self::Error>>
fn parse<'a, Iter, S>(&self, stream: S) -> Result<O, Vec<Self::Error>>
Parse a stream of tokens, yielding an output or any errors that were encountered along the way. Read more
Source§fn debug<T>(self, x: T) -> Debug<Self>
fn debug<T>(self, x: T) -> Debug<Self>
Include this parser in the debugging output produced by
Parser::parse_recovery_verbose
. Read moreSource§fn map<U, F>(self, f: F) -> Map<Self, F, O>
fn map<U, F>(self, f: F) -> Map<Self, F, O>
Map the output of this parser to another value. Read more
Source§fn map_with_span<U, F>(self, f: F) -> MapWithSpan<Self, F, O>
fn map_with_span<U, F>(self, f: F) -> MapWithSpan<Self, F, O>
Map the output of this parser to another value, making use of the pattern’s span when doing so. Read more
Source§fn map_err<F>(self, f: F) -> MapErr<Self, F>
fn map_err<F>(self, f: F) -> MapErr<Self, F>
Map the primary error of this parser to another value. Read more
Source§fn map_err_with_span<F>(self, f: F) -> MapErrWithSpan<Self, F>
fn map_err_with_span<F>(self, f: F) -> MapErrWithSpan<Self, F>
Map the primary error of this parser to another value, making use of the span from the start of the attempted
to the point at which the error was encountered. Read more
Source§fn try_map<U, F>(self, f: F) -> TryMap<Self, F, O>
fn try_map<U, F>(self, f: F) -> TryMap<Self, F, O>
After a successful parse, apply a fallible function to the output. If the function produces an error, treat it
as a parsing error. Read more
Source§fn validate<F, U>(self, f: F) -> Validate<Self, O, F>
fn validate<F, U>(self, f: F) -> Validate<Self, O, F>
Validate an output, producing non-terminal errors if it does not fulfil certain criteria. Read more
Source§fn labelled<L>(self, label: L) -> Label<Self, L>
fn labelled<L>(self, label: L) -> Label<Self, L>
Label the pattern parsed by this parser for more useful error messages. Read more
Source§fn to<U>(self, x: U) -> To<Self, O, U>
fn to<U>(self, x: U) -> To<Self, O, U>
Transform all outputs of this parser to a pretermined value. Read more
Source§fn foldl<A, B, F>(self, f: F) -> Foldl<Self, F, A, B>
fn foldl<A, B, F>(self, f: F) -> Foldl<Self, F, A, B>
Left-fold the output of the parser into a single value. Read more
Source§fn foldr<'a, A, B, F>(self, f: F) -> Foldr<Self, F, A, B>where
Self: Parser<I, (A, B)> + Sized,
A: IntoIterator,
A::IntoIter: DoubleEndedIterator,
F: Fn(A::Item, B) -> B + 'a,
fn foldr<'a, A, B, F>(self, f: F) -> Foldr<Self, F, A, B>where
Self: Parser<I, (A, B)> + Sized,
A: IntoIterator,
A::IntoIter: DoubleEndedIterator,
F: Fn(A::Item, B) -> B + 'a,
Right-fold the output of the parser into a single value. Read more
Source§fn ignored(self) -> Ignored<Self, O>where
Self: Sized,
fn ignored(self) -> Ignored<Self, O>where
Self: Sized,
Ignore the output of this parser, yielding
()
as an output instead. Read moreSource§fn collect<C>(self) -> Map<Self, fn(_: O) -> C, O>
fn collect<C>(self) -> Map<Self, fn(_: O) -> C, O>
Collect the output of this parser into a type implementing
FromIterator
. Read moreSource§fn then<U, P>(self, other: P) -> Then<Self, P>
fn then<U, P>(self, other: P) -> Then<Self, P>
Parse one thing and then another thing, yielding a tuple of the two outputs. Read more
Source§fn then_with<U, P, F: Fn(O) -> P>(
self,
other: F,
) -> ThenWith<I, O, U, Self, P, F>
fn then_with<U, P, F: Fn(O) -> P>( self, other: F, ) -> ThenWith<I, O, U, Self, P, F>
Parse one thing and then another thing, creating the second parser from the result of
the first. If you only have a couple cases to handle, prefer
Parser::or
. Read moreSource§fn flatten<T, Inner>(self) -> Map<Self, fn(_: O) -> Vec<T>, O>
fn flatten<T, Inner>(self) -> Map<Self, fn(_: O) -> Vec<T>, O>
Flatten a nested collection. Read more
Source§fn ignore_then<U, P>(self, other: P) -> IgnoreThen<Self, P, O, U>
fn ignore_then<U, P>(self, other: P) -> IgnoreThen<Self, P, O, U>
Parse one thing and then another thing, yielding only the output of the latter. Read more
Source§fn then_ignore<U, P>(self, other: P) -> ThenIgnore<Self, P, O, U>
fn then_ignore<U, P>(self, other: P) -> ThenIgnore<Self, P, O, U>
Parse one thing and then another thing, yielding only the output of the former. Read more
Source§fn padded_by<U, P>(
self,
other: P,
) -> ThenIgnore<IgnoreThen<P, Self, U, O>, P, O, U>
fn padded_by<U, P>( self, other: P, ) -> ThenIgnore<IgnoreThen<P, Self, U, O>, P, O, U>
Parse a pattern, but with an instance of another pattern on either end, yielding the output of the inner. Read more
Source§fn delimited_by<U, V, L, R>(
self,
start: L,
end: R,
) -> DelimitedBy<Self, L, R, U, V>
fn delimited_by<U, V, L, R>( self, start: L, end: R, ) -> DelimitedBy<Self, L, R, U, V>
Parse the pattern surrounded by the given delimiters. Read more
Source§fn or<P>(self, other: P) -> Or<Self, P>
fn or<P>(self, other: P) -> Or<Self, P>
Parse one thing or, on failure, another thing. Read more
Source§fn recover_with<S>(self, strategy: S) -> Recovery<Self, S>
fn recover_with<S>(self, strategy: S) -> Recovery<Self, S>
Apply a fallback recovery strategy to this parser should it fail. Read more
Source§fn or_not(self) -> OrNot<Self>where
Self: Sized,
fn or_not(self) -> OrNot<Self>where
Self: Sized,
Attempt to parse something, but only if it exists. Read more
Source§fn not(self) -> Not<Self, O>where
Self: Sized,
fn not(self) -> Not<Self, O>where
Self: Sized,
Parses a single token if, and only if, the pattern fails to parse. Read more
Source§fn repeated(self) -> Repeated<Self>where
Self: Sized,
fn repeated(self) -> Repeated<Self>where
Self: Sized,
Parse a pattern any number of times (including zero times). Read more
Source§fn separated_by<U, P>(self, other: P) -> SeparatedBy<Self, P, U>
fn separated_by<U, P>(self, other: P) -> SeparatedBy<Self, P, U>
Parse a pattern, separated by another, any number of times. Read more
Source§fn rewind(self) -> Rewind<Self>where
Self: Sized,
fn rewind(self) -> Rewind<Self>where
Self: Sized,
Parse a pattern. Afterwards, the input stream will be rewound to its original state, as if parsing had not
occurred. Read more
Source§fn boxed<'a>(self) -> BoxedParser<'a, I, O, Self::Error>where
Self: Sized + 'a,
fn boxed<'a>(self) -> BoxedParser<'a, I, O, Self::Error>where
Self: Sized + 'a,
Box the parser, yielding a parser that performs parsing through dynamic dispatch. Read more
impl<A: Copy, B: Copy, U> Copy for SeparatedBy<A, B, U>
Auto Trait Implementations§
impl<A, B, U> Freeze for SeparatedBy<A, B, U>
impl<A, B, U> RefUnwindSafe for SeparatedBy<A, B, U>
impl<A, B, U> Send for SeparatedBy<A, B, U>
impl<A, B, U> Sync for SeparatedBy<A, B, U>
impl<A, B, U> Unpin for SeparatedBy<A, B, U>
impl<A, B, U> UnwindSafe for SeparatedBy<A, B, U>
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more