Is it possible to declare parser function like nom's named macro?

[FantasyCheese]

Greetings,

I just start learning rust so maybe this is more of a rust question.

Basically I want to do something like let a_or_b = alt(('a', 'b'));, but type cannot be inferred correctly, and it cannot be declared at global scope.

Then I saw nom's named!(take4, take!(4));, which is close to what I want. But if I understand correctly, this is used with macro parser and not function parser. Also it seems that function parser is preferred in nom since long ago, and there are no macro parser in winnow to begin with.

So I guess my question is, do people nowadays just accept to write all parsers like this:

fn a_or_b<'s>(input: &mut &'s str) -> PResult<char> {
    alt(('a', 'b')).parse_next(input)
}

instead of something like let a_or_b = alt(('a', 'b'));?

By the way thanks for the great tutorial, it's really helpful for a beginner like me.

[epage]

FYI the macro parsers, like named!, aren't in nom anymore, not just one being preferred.

If you want to use let a_or_b within a function, that should work. The following compiles

use winnow::prelude::*;
use winnow::combinator::alt;

fn some_parser(input: &mut &str) -> PResult<u32> {
    let prefix = alt(("0o", "0b"));
    (prefix, winnow::ascii::digit1).recognize().parse_to().parse_next(input)
}

fn main() {
    some_parser.parse("0b101010").unwrap();
}

The challenge with using it in a global scope is that parsers are inherently mutable. This works with Rust's type system in most cases but there are some exceptions and I'm assuming a global is one.

For global parsers, is there a concern with putting it in a function?

[FantasyCheese]

Hey thanks for the information. No concern at all for global function parser in terms of functionality, it's just that noise/signal ratio seems pretty high in this pattern in Rust, considering parser combinator seems to be all about breaking parsers into tiny pieces.

Maybe it's because I first learned about the concept of parser combinator through Haskell, and also I'm used to define functions as global variable in other languages.

But anyway if global function is what people do in Rust now it's probably not that bad. I'll study more on Rust's type system and inference, and the "parsers are inherently mutable" part. Thanks again for your explanation!