impl FnMut. but since the function I return needs to capture the HashSet parameter, the compiler complains that the dynamic parameter must have the static lifetime. But I'm looking at the source of the tag() function and it seems to accept non-static tag parameters? I could clone the parameter so that the closure will have it for sure but I intend to pass the parameter a few parsers down so I'd rather not.. How am I supposed to handle that?
impl FnMut you return has to have the lifetime of the reference you pass in - e.g. &'a HashSet would become impl 'a + FnMut(...)
// sale_entires()
separated_list1(
separator::separator,
sale_entry
) #[test]
fn test_pair_of_sale_entry_petrol_short_separated() {
let input = "some_input";
let (_, sale_entries) = sale_entries(input).unwrap(); // THIS PANICS
assert_eq!(sale_entries.len(), 2);
}
#[test]
fn test_pair_of_sale_entry_petrol_short_separated_manual() {
let input = "some_input";
let (input, _entry) = sale_entry(input).unwrap();
let (input, _sep) = separator::separator(input).unwrap();
let (input, _entry) = sale_entry(input).unwrap();
assert_eq!(input, "");
}
I've been making a really simple parser for parsing boolean expressions with bools and C style identifiers that represent bools at runtime.
I've got a few outstanding questions that I could use some help with. I'll post them as separate comments for easier threading.
The code
https://gist.github.com/alexmadeathing/63ac3ba02d682dd791cba9918958c671
2 replies
1 reply
ExpressionErrorKind and an input position - basically ParseError, but for your own error kind. Then make all your parsers generic on the error type, but restrict it to ParseError + ContextError + YourErrorTrait
1 reply
Error, VerboseError et al)
Hi @xiretza:xiretza.xyz I've modified my code to use a custom trait instead of context() and that's working much nicer. Thanks for your help there! At the moment, for the purposes of testing, I'm keeping my concrete error type too, but I may follow your advice and simply expose the error trait once I've got everything working.
I guess the big question then is that failing test (I have now added a test case for: a & b & c). I have been able to modify the grammar on paper to support the test case. It seems like it would work in Nom using right recursion, but that would result in an incorrect sequence of evaluations of the & terms.
Left recursion has me stumped.
Does Nom have any tools to help with this situation? I can see it working if I use maybe a vector of operands and a post processing step to generate the output AST. Is there a way to do that without allocations?
let (input, init) = operand(input)?;
fold_many0(
preceded(
tag("&"),
cut(specific(Specific::ExpectAndExpression, operand)),
),
||init, // Lifetime error here
|a, b| Token::And(Box::new(a), Box::new(b)),
)(input)Clone/"FnNonOnce"
fn and_term<'a, E>(input: &'a str) -> IResult<&'a str, Token, E>
where
E: nom::error::ParseError<&'a str> + SpecificError<&'a str>,
{
let (input, init) = term_or_not_term(input)?;
let (input, mut root) = fold_many0(
preceded(
ws_tag("&"),
cut(specific(Specific::ExpectAndExpression, term_or_not_term)),
),
|| Token::Bool(true),
|a, b| Token::And(Box::new(a), Box::new(b)),
)(input)?;
// Well well well, what is this hot mess?
// Because the left side is always either And or Bool, we can
// simply loop until we find the bool then replace it with init
//
// #NOTE This is necessary because it's not possible to move
// init into the closures passed to fold_many0 as they expect
// FnMut, not FnOnce
let mut t = &mut root;
while let Token::And(a, _) = t {
t = a.as_mut();
}
debug_assert!(matches!(t, Token::Bool(_)));
*t = init;
Ok((input, root))
}let init = Some(init) outside and || init.take().unwrap() as the initializing closure.
hello, any nom_locate users? i have trouble wrapping my mind around the error i am getting...
Original &str input parser:
type MyResult<'a, T> = nom::IResult<&str, T>;
fn yang_version_arg(input: &str) -> MyResult<&str> {
tag("1.1")(input)
}seems to work fine...
Then i try to use nom_locate and follow the gitbuh readme with Span 'type':
type MyResult<'a, T> = nom::IResult<Span<'a>, T>;
fn yang_version_arg(input: Span) -> MyResult<&str> {
tag("1.1")(input)
}but i get errors across whole app codebase wherever i try to use any nom combinator/parser:
error[E0308]: mismatched types
--> src\parser\rfc7950\yang_version_stmt.rs:29:5
|
28 | fn yang_version_arg(input: Span) -> MyResult<&str> {
| -------------- expected `Result<(LocatedSpan<&str>, &str), nom::Err<nom::error::Error<LocatedSpan<&str>>>>` because of return type
29 | tag("1.1")(input)
| ^^^^^^^^^^^^^^^^^ expected `&str`, found struct `LocatedSpan`
|
= note: expected enum `Result<(LocatedSpan<&str>, &str), nom::Err<nom::error::Error<LocatedSpan<&str>>>>`
found enum `Result<(LocatedSpan<&str>, LocatedSpan<&str>), nom::Err<_>>`do i miss some piece of puzzle? isn't some deref supposed to happen to allow usage of all pre-build combinators in nom?
tag here returns LocatedSpan<&str> instead of &str, you may want to change the return type or convert it somehow.
tag and take are a special case here because their input and output are the same type?..