1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
//! Generalized free tuples. //! //! The `GTup` type is used to create generalized tuples. Because **Rust** doesn’t support type //! operators, `GTup` is used to create static tuples that can have an arbitrary size while //! remaining of the same recursive form. That’s very useful to implement traits for any kind of //! tuples. //! //! Feel free to dig in the documention of `GTup` for further details. /// The generalized free tuple. /// /// You can create arbitrary chains by nesting `GTup` types, or use the `gtup!` type macro. /// /// > Note: `GTup` is right-associative. /// /// # Examples /// /// ``` /// type Foo = GTup<i32, GTup<bool, f32>>; /// type Bar = GTup<GTup<i32, bool>, f32>; /// type Zoo = gtup![i32, bool, f32]; // Zoo == Foo /// ``` pub struct GTup<A, B>(pub A, pub B); #[macro_export] macro_rules! gtup_ty { ($t:ty) => { $t }; ($a:ty, $($r:tt)*) => { GTup<$a, gtup_ty!($($r)*)> } } #[macro_export] macro_rules! gtup_value { ($t:expr) => { $t }; ($a:expr, $($r:tt)*) => { GTup($a, gtup_value!($($r)*)) } } /// Generalized free tuple macro. /// /// If your compiler supports the `type_macros`*feature*, you can use this macro to create tuples /// without the syntactic nesting boilerplate. /// /// Furthermore, you can create values with this macro as well. /// /// # Examples /// /// ``` /// // type /// type Foo = GTup<i32, Chain<bool, f32>>; /// type Zoo = gtup!(:i32, bool, f32); // exactly the same type /// /// // value /// let triple = gtup!(42, false, 3.1415); /// ``` #[macro_export] macro_rules! gtup { (:$($a:tt)*) => { gtup_ty!($($a)*) }; ($($a:tt)*) => { gtup_value!($($a)*) } }