Hi there, I'm new to nom and as an learning experiment I've been trying to make a simplified JSON (just arrays of strings and string key:val pairs) parser using nom5. However, I've reached a point where I'm trying to parse the right side of a key:val pair wherein val could be an array or a quote delimited string.
I'm trying to do something like this:
fn parse_quotes(input: &str) -> IResult<&str, &str> { ... }
fn parse_array(input: &str) -> IResult<&str, Vec<&str>> { ... }
fn parse_value(input: &str) -> IResult<&str, _> {
alt((
parse_quotes,
parse_array
))(input)
}My problem here is, as parse_quotes and parse_array return different types, I'm not sure how to handle combining/branching them in alt or even if I should do that in the first place. I'd appreciate any pointers!
Hi, I'm running into an issue parsing bits. From what I can see the example at https://docs.rs/nom/5.0.1/nom/bits/fn.bits.html does not work. First of all the function should be bits and not take_bits but more elusively I get the following compile error:
error[E0283]: type annotations required: cannot resolve `_: nom::error::ParseError<(&[u8], usize)>`
bits::bits(bits::complete::take(4usize))(input)
^^^^^^^^^^
pub fn bits<I, O, E1: ParseError<(I, usize)>+ErrorConvert<E2>, E2: ParseError<I>, P>(parser: P) -> impl Fn(I) -> IResult<I, O, E2>
---------------------- required by this bound in `nom::bits::bits`Not sure how to proceed or how to explicitly give it the required type annotation.
I would like to parse a separated list that can have white spaces before and after the separators like [0 , 1 , 2]
I've got this working, but it only accounts for whitespaces after the separator:separated_list(preceded(char(','), multispace0), float)
How can I make it work with white spaces on both sides?
fn parser(i: &str) -> IResult<&str, String> {
// Works
escaped_transform(is_not("\\"), '\\', escape)(i)
// Hangs
//escaped_transform(take_while(|c| c != '\\'), '\\', escape)(i)
}
fn escape(i: &str) -> IResult<&str, &str> {
alt((
map(tag("\\"), |_| "\\"),
map(tag("\""), |_| "\""),
map(tag("n"), |_| "\n"),
))(i)
}
Any examples on how to use nom::branch::alt when combining parsers with different (map-ped) outputs?
Specifically, I have two sub-parsers, e.g. parse_int that returns (&str, i64) and parse_alpha that returns (&str, &str). How would one construct an alt(parse_int, parse_alpha) given that both sub-parsers have different return types?
impl From<IntegerLiteral> for Expression and impl From<Identifier> for Expression and alt(parse_integer_literal, parse_identifier) and so on...
factor() does in https://github.com/Geal/nom/blob/master/doc/making_a_new_parser_from_scratch.md#testing-the-parsers if it doesn't eat whitespaces... wish I could see where that snippet was taken from.
Hello!
It seems that certain combinator functions, such as take, don't have a prototype that would let using these with the ? operator in a function which returns IResult<I, O, E> with E being the default of E=(I,ErrorKind) (as in pub type IResult<I, O, E=(I,ErrorKind)> = Result<(I, O), Err<E>>; defined here https://docs.rs/nom/5.0.0/src/nom/internal.rs.html ):
error[E0277]: the trait bound `(&[u8], nom::error::ErrorKind): nom::error::ParseError<(_, usize)>` is not satisfied
--> src/main.rs:83:16
|
83 | let data = take(length - header_size)(input)?;
| ^^^^ the trait `nom::error::ParseError<(_, usize)>` is not implemented for `(&[u8], nom::error::ErrorKind)`
|
::: /home/marin/.cargo/registry/src/github.com-1ecc6299db9ec823/nom-5.0.1/src/bits/complete.rs:10:25
|
10 | pub fn take<I, O, C, E: ParseError<(I, usize)>>(count: C) -> impl Fn((I, usize)) -> IResult<(I, usize), O, E>
| ---------------------- required by this bound in `nom::complete::take`
|
= help: the following implementations were found:
<(I, nom::error::ErrorKind) as nom::error::ParseError<I>>I would like to know whether there is a way to have a function returning an IResult where the IResult could be an IResult::Err originating from any of the built-in combinators of nom, or if the use of the ? operator with nom is discouraged currently?
nom::complete::* into nom::bytes::complete::*. I would also like to know whether there would be a way to mix returning VerboseError errors from my own parsers, with the tuple results that seem to be the standard way to return errors from byte-based parsers with nom, or if again a function can't return both kind of errors and would recommend using match { } constructs instead of the ? operator?