Is there a way to convert Pairs<'_, T> into Pairs<'_, U> when T: Into<U>?

[dgkf]

I'm trying to provide multiple grammars which have 1-to-1 mappings between them, which means I can map rules to rules between grammars, and I would like to map them all to a single grammar for processing, but I can't find a way to map between Rule types.

Just as a quick example, I could have two separate grammars:

mod en {
    #[derive(Parser, Clone, Copy)]
    #[grammar = "english.pest"]
    pub struct EnglishParser
}

mod es {
    #[derive(Parser, Clone, Copy)]
    #[grammar = "spanish.pest"]
    pub struct SpanishParser
}

impl Into<en::Rule> for es::Rule {
    // ...
}

fn translate<'a, R>(p: Pairs<'a, R>) -> Pairs<'a, en::Rule>
where
    R: RuleType + Into<en::Rule>,
{
    // how to implement this?
}

Is there a way I can apply Into::<en::Rule>::into to each rule in Pairs<'_, es::Rule> to produce a Pairs<'_, en::Rule>?

I've only seen examples of creating a Pair in the docs using pest::state(). I've tried to map over my pairs to create an iterator of new Pair (not yet successfully), but this feels like I'm really going against the grain of the crate. Is there a better way?

[dgkf]

Just bumping this one. Still haven't figured out a good solution and would love some pointers if anyone has any ideas.

[tomtau]

Is there a way I can apply Into::en::Rule::into to each rule in Pairs<', es::Rule> to produce a Pairs<', en::Rule>?

Would using map work: https://docs.rs/pest/latest/pest/iterators/struct.Pairs.html#impl-DoubleEndedIterator-for-Pairs%3C'i,+R%3E ?

[dgkf]

Thanks for the suggestion 🙏 !

I feel like I must be missing something fundamental here. Sure, using map would let me apply a function to each Pair, but actually implementing a function that can convert from Pair<_, a::Rule> to Pair<_, b::Rule> is still unclear to me.

I haven an implementation for Into<b::Rule> for a::Rule, but in trying to write a function to affect the internal queue Rule I'm finding that all the internals that I would need to update this field are private. The most direct way I could think of was to deconstruct the Pair into its components and rebuild them with a different Rule, but this seems to be a nonstarter as queue isn't exposed through any public method and QueueableToken is only pub(crate).

Am I missing a more straightforward way of coercing pairs?

[tomtau]

And is it needed to construct Pairs? What if instead you defined a custom (abstract?) syntax tree type and mapped all those language Pairs into it?

[dgkf]

Ah, I think I see what you mean.

So instead of handling the conversion up-front, just wrap the entire parser in a new type (or implement a custom trait) and then convert into the rule type of choice when they're actually used.

I can try that.

[tomtau]

There are crates that can help with that conversion from Pairs such as https://crates.io/crates/pest_consume or https://crates.io/crates/pest-ast but they usually assume 1-to-1 mapping, so not sure how much they can help in this many-to-1 use case.

[dgkf]

Thanks! I think I've got a reasonable solution worked out. I have duplicate parsers and pratt_parsers for each localization, but then they all get mapped into the same AST.

I was originally really hung up on avoiding creating duplicate pratt_parsers for each, but your suggestion helped me realize that it might be easier just to have one for each localization.

Thanks for the tips! You can see the solution here if you're curious.

The pratt parser definition and localization mapping into equivalent english-language keywords is built with just a derive macro.