Two exactly opposite errors trying to use map_ctx

[Cookie04DE]

I have the following:

use chumsky::primitive::map_ctx;
use chumsky::ConfigParser;
use chumsky::{extra, primitive::just, Parser};

fn usize_ctx<'a>() -> impl Parser<'a, &'a str, (), extra::Context<usize>> + Clone {
    map_ctx(|num: &usize| num.to_string(), string_ctx())
    //map_ctx(|s: &String| s.parse().unwrap(), string_ctx())
}

fn string_ctx<'a>() -> impl Parser<'a, &'a str, (), extra::Context<String>> + Clone {
    just("".to_owned())
        .configure(|cfg, s: &String| cfg.seq(s.clone()))
        .ignored()
}

I get this error:

type mismatch in closure arguments
expected closure signature `for<'a> fn(&'a String) -> _`
  found closure signature `for<'a> fn(&'a usize) -> _`

This suggests to me that instead of the closure taking a &usize it should instead take &String. That's why I wrote the (currently commented out) line below.
This doesn't work either however:

type mismatch in closure arguments
expected closure signature `for<'a> fn(&'a usize) -> _`
    found closure signature `for<'a> fn(&'a String) -> _`

It's the exact oppsite error.
How do I use map_ctx?

[Zij-IT]

Edit: It could possibly be intended behavior, but I feel like that it's certainly odd, especially given that map for any other things in Chumsky allows you to swap between types.

I am 99% certain this is a bug in the definition of MapCtx's impl for ParserSealed. If we take a look at it, we see this:

impl<'a, I, O, E, A, F, Ctx> ParserSealed<'a, I, O, E> for MapCtx<A, F>
where
    I: Input<'a>,
    E: ParserExtra<'a, I>,
    A: Parser<'a, I, O, extra::Full<E::Error, E::State, Ctx>>,
    F: Fn(&E::Context) -> Ctx,
    Ctx: 'a,
{ 
    /* snip */
}

This means that it only implements ParserSealed for the E who's context is about to be mapped away, which is not accurate. I believe this should instead implement ParserSealed<I, O, Full<E::Error, E::State, Ctx>>

This also doesn't have a trivial solution at this time because if you try and implement the correct ParserSealed, you get an error because E is then unconstrained. Fixing that by adding an EmptyPhantom pushes the ball down further until we see why the error message was so weird for @Cookie04DE: InputRef's E must match the ParserExtra for which ParserSealed is being implemented for (which is the one getting mapped), as seen here:

error[E0053]: method `go` has an incompatible type for trait
   --> my_path/chumsky/src/primitive.rs:624:32
    |
614 | impl<'a, I, O, E, A, F, Ctx> ParserSealed<'a, I, O, Full<E::Error, E::State, Ctx>>
    |                - this type parameter
...
624 |     fn go<M: Mode>(&self, inp: &mut InputRef<'a, '_, I, E>) -> PResult<M, O> {
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |                                |
    |                                expected `Full<<... as ParserExtra<'a, ...>>::Error, ..., ...>`, found type parameter `E`
    |                                help: change the parameter type to match the trait: `&mut input::InputRef<'a, '_, I, extra::Full<<E as extra::ParserExtra<'a, I>>::Error, <E as extra::ParserExtra<'a, I>>::State, Ctx>>`

This doesn't work for any types which are going to map the context, because then we are implementing it where InputRef's E::Context differs (correctly) from what the parser is going to be having as it's E::Context.

This little snippet below is enough to make the compiler error, and shows how why this errors:

fn test<'a, F, P>(f: F, p: P) -> impl Parser<'a, &'a str, (), extra::Context<usize>> + Clone
where
    P: Clone,
    F: Clone,
    MapCtx<F, P>: Parser<'a, &'a str, (), extra::Context<usize>> + Clone,
{
    MapCtx {
        parser: p,
        mapper: f,
    }
}

@zesterer Is it intended that you cannot map from one type to another? I notice that the example compiles just fine, up until you add a little as u16 to the the lambda as seen here:

    let upper = just(b'0').configure(|cfg, ctx: &u8| cfg.seq(*ctx));
    
    // Uncomment the `as char` for a load of fun
    let mapped = map_ctx(|c: &u8| c.to_ascii_uppercase() /* as char */, upper);
    let inc = one_of::<_, _, extra::Default>(b'a'..=b'z')
        .ignore_with_ctx(mapped)
        .slice()
        .repeated()
        .at_least(1)
        .collect::<Vec<_>>();

    assert_eq!(
        inc.parse(b"aAbB" as &[_]).into_result(),
        Ok(vec![b"aA" as &[_], b"bB"])
    );
    assert!(inc.parse(b"aB").has_errors());

If this is intended behavior, I would probably want to consider renaming MapCtx to ModifyCtx so that it is clearer that you cannot map between types, but just modify the value of a particular type.

@Cookie04DE Sorry for the multiple tags, but it to sum up a long wall of text. Currently what you are after isn't supported. You can only modify the value that you are mapping, and therefor cannot change it's type.

[zesterer]

This is not intended, no. Do you have a simple test-case that reproduces this?

Edit: Never mind, I see what's going on.

[Cookie04DE]

Thank you very much for the quick and thorough answer @Zij-IT!
I hope this get's resolved, since this is currently blocking my implementations.
If this is intentional, please consider introducing another function that can actually change the type of the context.

[Zij-IT]

I'm just glad I could figure out what was going on to be honest. Those compiler messages were weird as weird gets. Out of curiosity, what are you currently attempting to parse that is hindered by this?

[Cookie04DE]

I am parsing something akin to Rust's raw string literals where the amount of hashtags you use decides how many hashtags followed by a double quote you can use inside the literal.
For me some parsers down the line need to know the amount to differentiate data from commands. It's also passing along some other data as the context, and some parsers need both and some parsers need just the amount. I need to "cut down" the context for those that only need the amount.