Mark parsing higher order tokens easier. (perhaps implement Compare for &[T] where T:Compare ?)

[rbtcollins]

Please complete the following tasks

• I have searched the discussions
• I have searched the open and rejected issues

winnow version

0.6.20

Describe your use case

I'm doing a small codecraft project with a language interpreter, and the design has multiple layers of parsing - string to tokens, and tokens to ast, etc.

It all works fine, but it is not very ergonomic:

To match [Token:X, Token:Y] I seem to need to do:

(
    one_of(|t| matches!(t, Token::X(_))).map(|t| match t {
                Token::X(s) => s.to_string(),
                _ => unreachable!(),
            }),
    one_of(|t| matches!(t, Token::Y)),
)

The ergonomics vs parsing strings are very vivid - there I could do

(any, "Y") or use literal() etc.

I cannot implement Compare, which literal depends on, as it hits the foreign type rule. For one_of, ContainsToken is sufficient.

pub fn test(tokens: Vec<Token>) -> anyhow::Result<()> {
    use winnow::token::literal;
    let mut p = literal(&[Token::Var][..]);
    p.parse(&tokens[..])
        .map(|_| ())
        .map_err(|e: ParseError<_, ContextError>| anyhow!("failed {e:?}"))
}

pub fn test2(tokens: Vec<Token>) -> anyhow::Result<()> {
    use winnow::token::one_of;
    let mut p = one_of(&[Token::Var][..]);
    p.parse(&tokens[..])
        .map(|_| ())
        .map_err(|e: ParseError<_, ContextError>| anyhow!("failed {e:?}"))
}

What I would like to be able to write things like

(Token::If, Token::LeftParen, expr, Token::RightParen, statement).parse_next(i)

Describe the solution you'd like

See the use case

Alternatives, if applicable

No response

Additional Context

No response

[epage]

FYI we are exploring improving lex+parsing in #591.