从元组创建数组

Question

我可以从这样的元组创建一个数组：

let a = (1, 2, 3);
let b = [a.0, a.1, a.2];

有没有办法在不命名元组的每个元素的情况下执行此操作？类似的东西：

let b = a.to_array();

Answer 1

目前没有这样的功能，但是完全可以扩展From特征的实现集来覆盖这个用例（及其反向）。 / p>

由于孤儿规则，此扩展程序必须位于core包中，但我们可以使用自定义特征轻松演示它：

use std::convert::Into;

trait MyFrom<T> {
    fn my_from(t: T) -> Self;
}

trait MyInto<U> {
    fn my_into(self) -> U;
}

impl<T, U> MyInto<U> for T
    where
        U: MyFrom<T>
{
    fn my_into(self) -> U { <U as MyFrom<T>>::my_from(self) }
}

impl<T> MyFrom<()> for [T; 0] {
    fn my_from(_: ()) -> Self { [] }
}

impl<T, A> MyFrom<(A,)> for [T; 1]
    where
        A: Into<T>,
{
    fn my_from(t: (A,)) -> Self { [t.0.into()] }
}

impl<T, A, B> MyFrom<(A, B)> for [T; 2]
    where
        A: Into<T>,
        B: Into<T>,
{
    fn my_from(t: (A, B)) -> Self { [t.0.into(), t.1.into()] }
}

定义后，使用起来非常简单：

fn main() {
    {
        let array: [i64; 0] = ().my_into();
        println!("{:?}", array);
    }
    {
        let array: [i64; 1] = (1u32,).my_into();
        println!("{:?}", array);
    }
    {
        let array: [i64; 2] = (1u32, 2i16).my_into();
        println!("{:?}", array);
    }
}

将打印：

[]
[1]
[1, 2]

反向实现会很容易，这里没什么神秘之处它只是样板（对于宏的欢呼！）。

Answer 2

不，没有。更重要的是，你甚至无法迭代元组。元组是异构的，因此它不适合转换为类似向量或数组的齐次类型。

您可以编写一个宏来允许迭代通用长度的元组的内容并收集它们（只要它的所有元素都是相同的类型），但您仍然必须单独访问/处理每个元素