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
//! Generalized free tuples. //! //! The `Chain` type is used to create chain of types. Because **Rust** doesn’t support type //! operators, `Chain` is used to create static tuples that can have an arbitrary size while //! remaining of the same form. That’s very useful to implement traits for any kind of types chain. //! Feel free to dig in the documention of `Chain` for further details. //! //! Plus, if your compiler supports the `type_macros`*feature*, you can use the `chain!` macro to //! build types chain without having to nest `Chain` in each others, which is very handy. /// The generalized free tuple. /// /// You can create arbitrary chains by nesting `Chain` types, or use the `chain!` type macro if your /// compiler allows you to. /// /// # Examples /// /// ``` /// type Foo = Chain<i32,Chain<bool,f32>>; /// type Bar = Chain<Chain<i32, bool>, f32>; /// type Zoo = chain![i32, bool, f32]; // Zoo == Foo /// ``` pub struct Chain<A, B>(pub A, pub B); /// If your compiler supports the `type_macros`*feature*, you can use this macro to create chains /// without the syntactic nesting boilerplate. /// /// # Examples /// /// ``` /// type Foo = Chain<i32,Chain<bool,f32>>; /// type Zoo = chain![i32, bool, f32]; // exactly the same type /// ``` #[macro_export] macro_rules! chain { ($t:ty) => {( $t )}; ($a:ty, $($r:tt)*) => {( Chain<$a, chain![$($r)*]> )} }