Macro bpaf::construct

macro_rules! construct {
    ($con:ident { $($tokens:tt)* }) => { ... };
    ($con:ident ( $($tokens:tt)* )) => { ... };
    ($ns:ident :: $con:ident { $($tokens:tt)* }) => { ... };
    ($ns:ident :: $con:ident ( $($tokens:tt)* )) => { ... };
    ($first:ident $($tokens:tt)*) => { ... };
    ([$first:ident $($tokens:tt)*]) => { ... };
    (@prepare $ty:tt [$($fields:tt)*] $field:ident (), $($rest:tt)*) => { ... };
    (@prepare $ty:tt [$($fields:tt)*] $field:ident () $($rest:tt)*) => { ... };
    (@prepare $ty:tt [$($fields:tt)*] $field:ident, $($rest:tt)*) => { ... };
    (@prepare $ty:tt [$($fields:tt)*] $field:ident $($rest:tt)*) => { ... };
    (@prepare [alt] [$first:ident $($fields:ident)*]) => { ... };
    (@prepare $ty:tt [$($fields:tt)*]) => { ... };
    (@make [named [$con:ident]] [$($fields:ident)*]) => { ... };
    (@make [pos [$con:ident]] [$($fields:ident)*]) => { ... };
    (@make [named [$ns:ident $con:ident]] [$($fields:ident)*]) => { ... };
    (@make [pos [$ns:ident $con:ident]] [$($fields:ident)*]) => { ... };
    (@make [pos] [$($fields:ident)*]) => { ... };
}

Compose several parsers to produce a single result

Every parser must succeed in order to produce a result for sequential composition and only one parser needs to succeed for a parallel one (construct!([a, b, c]))

Each parser must be present in a local scope and have the same name as struct field. Alternatively a parser can be present as a function producing a parser bpaf will call this function and use it’s result. Later option might be useful when single parser is used in several construct! macros

struct Res {
    a: bool,
    b: u32,
}

// parser defined as a local variable
let a: Parser<bool> = short('a').switch();

// parser defined as a function
fn b() -> Parser<u32> { short('b').argument("B").from_str() }
let res: Parser<Res> = construct!(Res { a, b() });

construct! supports following representations:

• structs with unnamed fields:

construct!(Res(a, b))

• structs with named fields:

construct!(Res {a, b})

• enums with unnamed fields:

construct!(Ty::Res(a, b))

• enums with named fields:

construct!(Ty::Res {a, b})

• tuples:

construct!(a, b)

• parallel composition, a equivalent of a.or_else(b).or_else(c)

construct!([a, b, c])