Module `multi`

Combinators applying their child parser multiple times

Structs

Count Parser implementation for the [count] combinator
Fill Parser implementation for the [fill] combinator
Fold Parser implementation for the [fold] combinator
FoldMany0 Parser implementation for the [fold_many0] combinator
FoldMany1 Parser implementation for the [fold_many1] combinator
FoldManyMN Parser implementation for the [fold_many_m_n] combinator
LengthCount Parser implementation for the [length_count] combinator
LengthValue Parser implementation for the [length_value] combinator
Many Parser implementation for the [many] combinator
Many0 Parser implementation for the [many0] combinator
Many0Count Parser implementation for the [many0_count] combinator
Many1 Parser implementation for the [many1] combinator
Many1Count Parser implementation for the [many1_count] combinator
ManyMN Parser implementation for the [many_m_n] combinator
ManyTill Parser implementation for the [many_till] combinator
SeparatedList0 Parser implementation for the [separated_list0] combinator
SeparatedList1 Parser implementation for the [separated_list1] combinator

Functions

count Runs the embedded parser count times, gathering the results in a Vec
fill Runs the embedded parser repeatedly, filling the given slice with results.
fold Applies a parser and accumulates the results using a given function and initial value. Fails if the amount of time the embedded parser is run is not within the specified range.
fold_many0 Repeats the embedded parser, calling g to gather the results.
fold_many1 Repeats the embedded parser, calling g to gather the results.
fold_many_m_n Repeats the embedded parser m..=n times, calling g to gather the results

length_count

Gets a number from the first parser, then applies the second parser that many times.

Arguments

f The parser to apply to obtain the count.
g The parser to apply repeatedly.

# use nom::{Err, error::{Error, ErrorKind}, Needed, IResult, Parser};
use nom::number::complete::u8;
use nom::multi::length_count;
use nom::bytes::complete::tag;
use nom::combinator::map;

length_data
Gets a number from the parser and returns a subslice of the input of that size. If the parser returns Incomplete, length_data will return an error.

Arguments
- f The parser to apply.
```
# use nom::{Err, error::ErrorKind, Needed, IResult, Parser};
use nom::number::complete::be_u16;
use nom::multi::length_data;
use nom::bytes::complete::tag;
```
length_value
Gets a number from the first parser, takes a subslice of the input of that size, then applies the second parser on that subslice. If the second parser returns Incomplete, length_value will return an error.

Arguments
- f The parser to apply.
- g The parser to apply on the subslice.
```
# use nom::{Err, error::{Error, ErrorKind}, Needed, IResult, Parser};
use nom::number::complete::be_u16;
use nom::multi::length_value;
use nom::bytes::complete::tag;
```
many
Repeats the embedded parser and collects the results in a type implementing Extend + Default. Fails if the amount of time the embedded parser is run is not within the specified range.

Arguments
- range Constrains the number of iterations.
  - A range without an upper bound a.. is equivalent to a range of a..=usize::MAX.
  - A single usize value is equivalent to value..=value.
  - An empty range is invalid.
- parse The parser to apply.
many0 Repeats the embedded parser, gathering the results in a Vec.
many0_count Repeats the embedded parser, counting the results
many1 Runs the embedded parser, gathering the results in a Vec.
many1_count Runs the embedded parser, counting the results.
many_m_n Repeats the embedded parser m..=n times
many_till Applies the parser f until the parser g produces a result.
separated_list0 Alternates between two parsers to produce a list of elements.
separated_list1 Alternates between two parsers to produce a list of elements until Err::Error.