Label not taken into consideration on alpha.6

[soywod]

I have the following code that is similar to your calculator in the tutorial:

#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
pub enum ListEnvelopesFilter {
    And(Box<ListEnvelopesFilter>, Box<ListEnvelopesFilter>),
    Or(Box<ListEnvelopesFilter>, Box<ListEnvelopesFilter>),
    Not(Box<ListEnvelopesFilter>),
    Folder(String),
    Before(DateTime<Local>),
    After(DateTime<Local>),
    From(String),
    To(String),
    Subject(String),
    Body(String),
    Keyword(String),
    None,
}

pub type ParserError<'a> = extra::Err<Rich<'a, char>>;

pub(crate) fn filter<'a>() -> impl Parser<'a, &'a str, ListEnvelopesFilter, ParserError<'a>> + Clone {
    recursive(|filter| {
        let filter = choice((
            filter.delimited_by(just(LPARENS), just(RPARENS)),
            condition(),
        ))
        .padded();

        let not = just("not").padded().repeated().foldr(filter, |_, filter| {
            ListEnvelopesFilter::Not(Box::new(filter))
        });

        let and = not.clone().foldl(
            just("and").padded().ignored().then(not).repeated(),
            |left, (_, right)| ListEnvelopesFilter::And(Box::new(left), Box::new(right)),
        );

        let or = and.clone().foldl(
            just("or").padded().ignored().then(and).repeated(),
            |left, (_, right)| ListEnvelopesFilter::Or(Box::new(left), Box::new(right)),
        );

        or
    })
}

fn condition<'a>() -> impl Parser<'a, &'a str, ListEnvelopesFilter, ParserError<'a>> + Clone {
    choice((
        from(),
        to(),
        subject(),
        body(),
        keyword(),
        before(),
        after(),
    ))
}

// All parsers are similar, so I post only one:

fn from<'a>() -> impl Parser<'a, &'a str, ListEnvelopesFilter, ParserError<'a>> + Clone {
    just("from")
        .padded()
        .ignore_then(val())
        .map(ListEnvelopesFilter::From)
}

No matter which .labelled() and .as_context() I put, the result is the same:

Error: found 'u' expected 'n', '(', 'f', 't', 's', 'b', 'k', or 'a'
   ╭─[query:1:1]
   │
 1 │ u
   │ ┬  
   │ ╰── found 'u' expected 'n', '(', 'f', 't', 's', 'b', 'k', or 'a'
───╯

I am using the alpha.6 with the label feature on. What am I missing?

[zesterer]

Could you give some more information about where you're adding .labelled?

[soywod]

Here a small version of the code, it still does not use the label even without the recursive:

#[test]                                                                              
fn repro() {                                                                         
    use chumsky::prelude::*;                                                         
                                                                                     
    #[derive(Debug, Eq, PartialEq)]                                                  
    enum Filter {                                                                    
        From(String),                                                                
        To(String),                                                                  
        Subject(String),                                                             
        Body(String),                                                                
        None,                                                                        
    }                                                                                
                                                                                     
    fn filter<'a>() -> impl Parser<'a, &'a str, Filter, extra::Err<Rich<'a, char>>> {
        choice((                                                                     
            just("from")                                                             
                .labelled("From1")                                                   
                .ignore_then(text::ident().labelled("From2"))                        
                .map(|from: &str| Filter::From(from.to_string()))                    
                .labelled("From3"),                                                  
            just("to")                                                               
                .ignore_then(text::ident())                                          
                .map(|to: &str| Filter::To(to.to_string())),                         
            just("subject")                                                          
                .ignore_then(text::ident())                                          
                .map(|subject: &str| Filter::Subject(subject.to_string())),          
            just("body")                                                             
                .ignore_then(text::ident())                                          
                .map(|body: &str| Filter::Body(body.to_string())),                   
        ))                                                                           
        .padded()                                                                    
    }                                                                                
                                                                                     
    assert_eq!(filter().parse("wrong").into_result(), Ok(Filter::None))              
}                                                                                    

assertion `left == right` failed
  left: Err([found ''w'' at 0..1 expected ''f'', ''t'', ''s'', or ''b''])
 right: Ok(None)

[soywod]

It may be related to #518, I was able to get the context only once if I replace just by text::keyword and try to parse [good: found '[' at 0..1 expected "Good label". If I try to parse wgood: found end of input at 0..5 expected something else. In this last one, if I add as_context(), then I can see the label in err.contexts() (but still not visible in the final error message).

[zesterer]

Any chance you could point your project at this git repository, specifically the commit 6837537 ? I'm wondering whether my recent change has fixed this.

[soywod]

Looks way better, thank you! But it seems I still have trouble with text::* parsers. For example just("good").labelled("good") works as expected now, but text::keyword("good").labelled("good") still outputs expected something else. Same with spaces: just(' ').repeated().label("space between filters") works well, but not text::whitespace().label("space between filters") which leads to expected something else.

[zesterer]

Thanks for that information. I've found the problem with text::keyword (it was actually a subtle issue in try_map, of all things!), d93e12a contains that fix.

Regarding text::whitespace: that behaviour is actually expected (although I agree that it's suboptimal). Resolving it will require a slightly larger rework of the way error handling works. However, I've been doing a lot of thinking about that recently and I've come up with a design that I believe should entirely resolve these problems: I'll probably try implementing it over the next few days.

[soywod]

Awesome, thank you for your great work! I can go forward now, I will replace my custom keyword and spaces later. Diagnostics are way better now:

Error: cannot parse search emails query `subjectt fact`
   ╭─[query:1:8]
   │
 1 │ subjectt fact
   │        ┬  
   │        ╰── found t expected space after `subject`
───╯

Error: cannot parse search emails query `from test and wrong filter`
   ╭─[query:1:15]
   │
 1 │ from test and wrong filter
   │               ┬  
   │               ╰── found w expected space after `and`, `not`, `before`, `after`, `from`, `to`, `subject`, `body`, `keyword`, or (nested filter)
───╯

[soywod]

I guess we can close the discussion and keep #518 for tracking text::* issues?

[zesterer]

Great to hear! I think this can be closed, yes: the fundamental problem with labelled is now fixed, the remaining problems are elsewhere.

[soywod]

When do you plan to release a new alpha containing your previous fixes regarding labels?

[soywod]

Probably soon, I think there are enough changes for it to be worth it!

Awesome!

I'd really like to finally push for 1.0 stable, but there's still a fairly substantial todo list :(

Then I wish you good luck, my tool is also accumulating betas without reaching the v1, frustrating!