Macro tuple_list 

macro_rules! tuple_list {
    () => { ... };
    ($i:ident) => { ... };
    ($i:ident,) => { ... };
    ($i:ident, $($e:ident),*) => { ... };
    ($i:ident, $($e:ident),*,) => { ... };
    ($i:expr) => { ... };
    ($i:expr,) => { ... };
    ($i:expr, $($e:expr),*) => { ... };
    ($i:expr, $($e:expr),*,) => { ... };
}

Macro creating tuple list values from list of expressions.

Examples

Main use of this macro is to create tuple list values:

use tuple_list::tuple_list;
 
let list = tuple_list!(10, false, "foo");
 
assert_eq!(
  list,
  (10, (false, ("foo", ()))),
)

Aside from that, tuple_list! can sometime be used to define trivial types, but using macro tuple_list_type! is recommended instead:

// Trivial types work just fine with `tuple_list!`.
let list: tuple_list_type!(i32, bool, String) = Default::default();
 
// More complex types will fail when using `tuple_list!`,
// but will work with `tuple_list_type!`.
use tuple_list::tuple_list_type;
 
let list: tuple_list_type!(
    &'static str,
    HashMap<i32, i32>,
    <std::vec::Vec<bool> as IntoIterator>::Item,
) = tuple_list!("foo", HashMap::new(), false);

It can also be used to unpack tuples:

let tuple_list!(a, b, c) = tuple_list!(10, false, "foo");
 
assert_eq!(a, 10);
assert_eq!(b, false);
assert_eq!(c, "foo");

Unfortunately, due to Rust macro limitations only simple, non-nested match patterns are supported.