asks for \n for every pattern

[Vaimer9]

Here is the source code. The main function only prints the output of the function in the provided code
every pattern the parser catches it only returns with the following error:

Err(
    [
        Simple {
            span: 4..5,
            reason: Unexpected,
            expected: {
                None,
            },
            found: Some(
                '\n',
            ),
            label: None,
        },
    ],
)

what could be the main issue?

the input used in to produce the following error was 32.0

[zesterer]

Hello! The issue you mention is caused by the fact that your expression parser doesn't allow for whitespace and probably needs a .padded() on the end of it. On Unix systems, saving a file will generally result in a newline character being placed at the end. This means that the parser is encountering a newline that it's not expecting, hence the error.

A few more things to consider about the parser:

• .then_ignore(end()) is used in several different places. This pattern is used to force a parser to read until the very end of an input, and so should generally only go at the very highest level of the parser. Some people even omit it from the parser entirely, preferring to add it to the place where the parser gets invoked, like my_parser.then_ignore(end()).parse(input). Indeed, I'm tempted to make this behaviour 'opt-out' for a future release.

• Your lexer function is actually exhibiting behaviour more typical of a parser. I would recommend renaming it, or otherwise separating lexing and parsing into distinct steps (for example, as the nano_rust example does). Having lexing and parsing as distinct steps can often be useful because it avoids needing to remember to add .padded() calls throughout the parser itself.

I hope this helps!

[Vaimer9]

updated the code, here's the newer error:

Err(
    [
        Simple {
            span: 0..1,
            reason: Unexpected,
            expected: {
                None,
            },
            found: Some(
                '3',
            ),
            label: None,
        },
    ],
)

before I was somewhat expecting the problem to be something related to .padding() but I have not clue now

[zesterer]

The problem you have is subtle, but might make more sense in hindsight.

At the lowest level, you're trying the decl rule and then the expr rule. The decl rule in particular is defined as one of function, assign, or cmd.

This last rule, cmd, is of particular interest to us because it's (effectively) defined as:

let cmd = ident
    .repeated();

If you take a look at the docs for repeated, you'll see that it comes with the following warning:

Be aware that the parser will accept no occurences of the pattern too. Consider using Repeated::at_least instead if it better suits your use-case.

This case is being hit here! cmd is permitted to accept no input at all, so it erroneously decides to ignore the 32.0 because it doesn't match what it expects, but it is permitted to accept nothing at all.

Indeed, if we add .at_least(1) at the end of .repeated(), we find that the parser works correctly.

Hopefully this helps!

[Vaimer9]

Works like a charm, thank you for your help!