Macro aoc_parse::parser

macro_rules! parser {
    (@seq _ [ => $mapper:expr ] [ $($stack:tt)* ] [ $($pats:tt ,)* ]) => { ... };
    (@seq $label:ident [ => $mapper:expr ] [ $($stack:tt)* ] [ $($pats:tt ,)* ]) => { ... };
    (@seq $label:tt [ as $ty:ty ] [ $top:expr , $($stack:expr ,)* ] [ $($pats:tt ,)* ]) => { ... };
    (@seq $label:tt [ * ? $($tail:tt)* ] [ $($stack:expr ,)* ] [ $($pats:tt ,)* ]) => { ... };
    (@seq $label:tt [ + ? $($tail:tt)* ] [ $($stack:expr ,)* ] [ $($pats:tt ,)* ]) => { ... };
    (@seq $label:tt [ * $($tail:tt)* ] [ $top:expr , $($stack:expr ,)* ] [ $top_pat:tt , $($pats:tt ,)* ]) => { ... };
    (@seq $label:tt [ + $($tail:tt)* ] [ $top:expr , $($stack:expr ,)* ] [ $top_pat:tt , $($pats:tt ,)* ]) => { ... };
    (@seq $label:tt [ ? $($tail:tt)* ] [ $top:expr , $($stack:tt)* ] [ $top_pat:tt , $($pats:tt ,)* ]) => { ... };
    (@seq $label:tt [ * $($tail:tt)* ] [ ] [ $($pats:tt ,)* ]) => { ... };
    (@seq $label:tt [ + $($tail:tt)* ] [ ] [ $($pats:tt ,)* ]) => { ... };
    (@seq $label:tt [ ? $($tail:tt)* ] [ ] [ $($pats:tt ,)* ]) => { ... };
    (@seq $label:tt [ $f:ident ( $($args:tt)* ) $($tail:tt)* ] [ $($stack:expr ,)* ] [ $($pats:tt ,)* ]) => { ... };
    (@seq $label:tt [ ( $sublabel:ident : $($expr:tt)* ) $($tail:tt)* ] [ $($stack:expr ,)* ] [ $($pats:tt ,)* ]) => { ... };
    (@seq $label:tt [ $x:literal $($tail:tt)* ] [ $($stack:expr ,)* ] [ $($pats:tt ,)* ]) => { ... };
    (@seq $label:tt [ $x:tt $($tail:tt)* ] [ $($stack:expr ,)* ] [ $($pats:tt ,)* ]) => { ... };
    (@seq $label:tt [ ] [ $($parts:expr ,)* ] [ $($pats:tt ,)* ]) => { ... };
    (@seq $label:tt [ $($tail:tt)* ] [ $($parts:expr ,)* ] [ $($pats:tt ,)* ]) => { ... };
    (@reverse [ ] [ ]) => { ... };
    (@reverse [ ] [ $out:expr ]) => { ... };
    (@reverse [ $head:expr , $($tail:expr ,)* ] [ ]) => { ... };
    (@reverse [ $head:expr , $($tail:expr ,)* ] [ $out:expr ]) => { ... };
    (@reverse_pats [ ] [ $out:pat , ]) => { ... };
    (@reverse_pats [ ] [ $($out:pat ,)* ]) => { ... };
    (@reverse_pats [ #, $($tail:tt ,)* ] [ $( $out:pat , )* ]) => { ... };
    (@reverse_pats [ $head:pat , $($tail:tt ,)* ] [ $($out:pat ,)* ]) => { ... };
    (@prim $x:ident) => { ... };
    (@prim $x:literal) => { ... };
    (@prim ( $($nested:tt)* )) => { ... };
    (@prim { $($nested:tt)* }) => { ... };
    (@args [ , $($tail:tt)* ] [ $($seq:tt)* ] ( $( $arg:expr , )* )) => { ... };
    (@args [ $next:tt $($tail:tt)* ] [ $($seq:tt)* ] ( $( $out:expr , )* )) => { ... };
    (@args [] [] $out:expr) => { ... };
    (@args [] [ $($seq:tt)+ ] ( $( $out:expr , )* )) => { ... };
    (@list [ , $($tail:tt)* ] [ $($seq:tt)* ] [ ]) => { ... };
    (@list [ , $($tail:tt)* ] [ $($seq:tt)* ] [ $out:expr ]) => { ... };
    (@list [ $next:tt $($tail:tt)* ] [ $($seq:tt)* ] [ $($out:expr)? ]) => { ... };
    (@list [ ] [ ] [ ]) => { ... };
    (@list [ ] [ ] [ $out:expr ]) => { ... };
    (@list [ ] [ $($seq:tt)+ ] [ $( $out:expr )? ]) => { ... };
    (@ $($tail:tt)*) => { ... };
    ($label:ident : $($tail:tt)*) => { ... };
    ($($tail:tt)*) => { ... };
}

Macro that creates a parser for a given pattern.

See the top-level documentation for more about how to write patterns.

Here’s a formal syntax for patterns:

pattern ::= expr

expr ::= label
  | label "=>" rust_expr    -- custom conversion

label ::= cast
  | ident ":" seq           -- labeled subpattern

seq ::= term
  | seq term                -- concatenated subpatterns

term ::= prim
  | term "*"                -- optional repeating
  | term "+"                -- repeating
  | term "?"                -- optional

prim ::= "(" expr ")"
  | ident "(" expr,* ")"    -- function call
  | ident                   -- named parser (when not followed by `(`)
  | literal                 -- exact string
  | "{" expr,* "}"          -- one-of syntax

ident ::= a Rust identifier
expr ::= a Rust expression
literal ::= a Rust literal