有没有办法为可能具有任何数字元素的元组隐含特征？

Question

我有这样一个特质：

trait Foo {
    fn do_something(self) -> Self;
}

我想为一个元组实现此特征，该元组可能具有任意数量的实现此特征的元素。

impl<T> Foo for (T, T) where T: Foo {
    fn do_something(self) -> Self {
        let (t0, t1) = self;
        (t0.do_something(), t1.do_something())
    }
}

impl<T> Foo for (T, T, T) where T: Foo {
    fn do_something(self) -> Self {
        let (t0, t1, t2) = self;
        (t0.do_something(), t1.do_something(), t2.do_something())
    }
}

// and so on...

Answer 1

注意：我不确定你是否应该这样做，但无论如何，这里有一个方法。（对我来说感觉很奇怪，这可能是因为我不知道如何制作更好的宏。）

同质元组(T, T)

你描述的方式：

impl<T> Foo for (T, T) where T: Foo

这里，整个元组必须是同质的（即由于单态化而 不起作用(MyType, MyType2).do_something()） 。这引发了一个问题，因为元组适用于异构数据。

如果您仍然想要只实现一个同构元组的特征，我们可以像标准库那样实现一个宏来实现不同长度元组的特征，并进行一些修改。（单击src右侧impl即可查看其来源。）

macro_rules! replace_expr {
    ($_t:tt $sub:ty) => {$sub};
}

macro_rules! tuple_impls {
    ( $( $name:ident )+ ) => {
        impl<T: Foo> Foo for ($(replace_expr!(($name) T),)+)
        {
            fn do_something(self) -> Self {
                let ($($name,)+) = self;
                ($($name.do_something(),)+)
            }
        }
    };
}

tuple_impls! { A }
tuple_impls! { A B }
tuple_impls! { A B C }
tuple_impls! { A B C D }
tuple_impls! { A B C D E }
tuple_impls! { A B C D E F }
tuple_impls! { A B C D E F G }
tuple_impls! { A B C D E F G H }
tuple_impls! { A B C D E F G H I }
tuple_impls! { A B C D E F G H I J }
tuple_impls! { A B C D E F G H I J K }
tuple_impls! { A B C D E F G H I J K L }

操场

异构元组(T1, T2)

如果您可以正常(MyType, MyType2).do_something()工作（两者都实现了该Foo特征），您可以尝试这个更简单的宏：

macro_rules! tuple_impls {
    ( $( $name:ident )+ ) => {
        impl<$($name: Foo),+> Foo for ($($name,)+)
        {
            fn do_something(self) -> Self {
                let ($($name,)+) = self;
                ($($name.do_something(),)+)
            }
        }
    };
}

tuple_impls! { A }
tuple_impls! { A B }
tuple_impls! { A B C }
tuple_impls! { A B C D }
tuple_impls! { A B C D E }
tuple_impls! { A B C D E F }
tuple_impls! { A B C D E F G }
tuple_impls! { A B C D E F G H }
tuple_impls! { A B C D E F G H I }
tuple_impls! { A B C D E F G H I J }
tuple_impls! { A B C D E F G H I J K }
tuple_impls! { A B C D E F G H I J K L }

操场

Answer 2

不。（除非您准备好使用宏 - 请参阅其他答案）

Rust 中的元组有固定的长度，就像数组一样。我不相信你可以表达“任意长度的元组”的概念。

换句话说，2 个元素的元组与 3 个元素的元组是不同的复合类型。如果您坚持使用元组，则必须采用上面概述的解决方案。

使用集合？（例如为现有的别名并在其上实现特征）？