Macro chumsky::select

macro_rules! select {
    ($($p : pat $(if $guard : expr) ? => $out : expr), + $(,) ?) => { ... };
}

Create a parser that selects one or more input patterns and map them to an output value.

This is most useful when turning the tokens of a previous compilation pass (such as lexing) into data that can be used for parsing, although it can also generally be used to select inputs and map them to outputs. Any unmapped input patterns will become syntax errors, just as with filter.

Internally, select! is a loose wrapper around filter_map and thinking of it as such might make it less confusing.

The macro is semantically similar to a match expression and so supports pattern guards too.

Examples

// The type of our parser's input (tokens like this might be emitted by your compiler's lexer)
#[derive(Clone, Debug, PartialEq)]
enum Token {
    Num(u64),
    Bool(bool),
    LParen,
    RParen,
}

// The type of our parser's output, a syntax tree
#[derive(Debug, PartialEq)]
enum Ast {
    Num(u64),
    Bool(bool),
    List(Vec<Ast>),
}

// Our parser converts a stream of input tokens into an AST
// `select!` is used to deconstruct some of the tokens and turn them into AST nodes
let ast = recursive::<_, _, _, _, Cheap<Token>>(|ast| {
    let literal = select! {
        Token::Num(x) => Ast::Num(x),
        Token::Bool(x) => Ast::Bool(x),
    };

    literal.or(ast
        .repeated()
        .delimited_by(Token::LParen, Token::RParen)
        .map(Ast::List))
});

use Token::*;
assert_eq!(
    ast.parse(vec![LParen, Num(5), LParen, Bool(false), Num(42), RParen, RParen]),
    Ok(Ast::List(vec![
        Ast::Num(5),
        Ast::List(vec![
            Ast::Bool(false),
            Ast::Num(42),
        ]),
    ])),
);