Macro choice::choice

macro_rules! choice {
    [$t:ty] => { ... };
    [$t1:ty, $($t2:ty),+] => { ... };
    (0 <- $x:expr) => { ... };
    (1 <- $x:expr) => { ... };
    (2 <- $x:expr) => { ... };
    (3 <- $x:expr) => { ... };
    (4 <- $x:expr) => { ... };
    (5 <- $x:expr) => { ... };
    (6 <- $x:expr) => { ... };
    (7 <- $x:expr) => { ... };
    (8 <- $x:expr) => { ... };
    (9 <- $x:expr) => { ... };
    (10 <- $x:expr) => { ... };
    (11 <- $x:expr) => { ... };
    (0 -> !) => { ... };
    (1 -> !) => { ... };
    (2 -> !) => { ... };
    (3 -> !) => { ... };
    (4 -> !) => { ... };
    (5 -> !) => { ... };
    (6 -> !) => { ... };
    (7 -> !) => { ... };
    (8 -> !) => { ... };
    (9 -> !) => { ... };
    (10 -> !) => { ... };
    (11 -> !) => { ... };
    (12 -> !) => { ... };
    (0 -> $v:ident) => { ... };
    (1 -> $v:ident) => { ... };
    (2 -> $v:ident) => { ... };
    (3 -> $v:ident) => { ... };
    (4 -> $v:ident) => { ... };
    (5 -> $v:ident) => { ... };
    (6 -> $v:ident) => { ... };
    (7 -> $v:ident) => { ... };
    (8 -> $v:ident) => { ... };
    (9 -> $v:ident) => { ... };
    (10 -> $v:ident) => { ... };
    (11 -> $v:ident) => { ... };
}

Syntactic sugar for (1) a Choice among types, (2) a value inhabiting a Choice, and (3) destructuring for one of these values.

Note: the choice!(1 -> ?)/etc forms should no longer be necessary once exhaustive_patterns stabilizes.

Example

use choice::choice;
let c: choice![u64, &'static str, char] =
    choice!(2 <- 'c'); //         ^^^^ index 2
match c {
    choice!(0 -> v) => unreachable!("v: u64"),
    choice!(1 -> v) => unreachable!("v: &'static str"),
    choice!(2 -> v) => assert_eq!(v, 'c'),
    choice!(3 -> !) => unreachable!("v: Never"),
}