How would go about building parsers at runtime?

[schneiderfelipe]

I'm aware of the boxed method, but I would like to get a simple example on using it to create a parser at runtime.

[zesterer]

Normally, parsers (like iterators) have a unique type that depends on how you compose them.

For example, the type of just("a").or(just("b")) will look something like Or<Just<...>, Just<...>>.

If you're trying to build up parsers at runtime, this is obviously not particularly useful. 'Simple' code like the following will fail to compile due to the parsers having mismatched types:

let twitter_alias = just('@').ignore_then(text::ident());

let mastodon_alias = just('@')
    .ignore_then(text::ident())
    .chain(just('@').ignore_then(url));

// Error: type mismatch between match arms
let alias_parser = match get_alias_mode_at_runtime() {
    AliasMode::Twitter => twitter_alias,
    AliasMode::Mastodon => mastodon_alias,
};

You can use .boxed(), as you say, to homogenise the parser types (it uses dynamic dispatch internally which incurs a small performance hit, but this is usually insubstantial enough to not matter).

...

// No compilation error: both parsers now have type `Boxed<...>`!
let alias_parser = match get_alias_mode_at_runtime() {
    AliasMode::Twitter => twitter_alias.boxed(),
    AliasMode::Mastodon => mastodon_alias.boxed(),
};

This is a technique I've seen some people use for building up operator precedence parsers, for example.

[schneiderfelipe]

Hey @zesterer thanks! That's exactly the kind of example I was looking for! ✨

[Troels51]

@zesterer, resurrecting an old thread with a related question.
I used the technique described here to create dynamic parsers, but now I want to combine them.
Specifically, I have a list of boxed parsers that I want to chain together, delimited by a character, but I can't seem to find a way to do that. Any pointers would be helpful.

[zesterer]

You could use mutation, like so:

let mut parser = empty().boxed();

for p in parsers_to_add {
    parser = parser.then(p).boxed();
}

[Troels51]

That doesn't seem to work, as the output of then is a tuple, which means that the first iteration gives a parser that returns a tuple of size 2 and the next iteration wants to output a tuple of size 3 meaning that the types of the parser at each iteration is different.
Ill try to fiddle with this idea but with chain as that always has an output of a vec

[Troels51]

I ended up solving it by using chain in the loop. And on initialization of the parser I did something like this:

let mut full_parser = empty().map(|x| Vec::<value::new()).boxed()

And then map was to get the type of the parser to match what chain needed