Suppose I have a type A<T> that depends on type T and want to use cargo features to decide T at compile time.
I could do something like
#[cfg(feature = "a")]
let s = A<i64>
#[cfg(feature = "b")]
let s = A<bool>
and so on. However this is not very efficient once I have many types that all depend on T, like
A1, ... A100
Is there a cleaner way to do this for many types? Maybe a macro, or better some type definition. Something like
#[cfg(feature = "a")]
type T = i64
#[cfg(feature = "b")]
type T = bool
#[cfg(feature = "a")]
type TheT = f64;
#[cfg(feature = "b")]
type TheT = bool;
struct A1_<T>(...);
struct A2_<T>(...);
type A1 = A1_<TheT>;
type A2 = A2_<TheT>;
Or alternatively you can hack it with default type parameters:
#[cfg(feature = "a")]
type TheT = f64;
#[cfg(feature = "b")]
type TheT = bool;
// this makes TheT the *default* T, so that when
// somebody just writes A1, it becomes A1<TheT>
struct A1<T = TheT>(...);
struct A2<T = TheT>(...);
That said, it looks like you are creating mutually exclusive features here. These are generally discouraged and you may want to seek an alternative design. (see e.g. this recent discussion).