如何从向量创建元组？

Question

这是一个示例，它将字符串拆分并解析每个项，并将其放入元组中，在编译时已知其大小。

use std::str::FromStr;

fn main() {
    let some_str = "123,321,312";
    let num_pair_str = some_str.split(',').collect::<Vec<&str>>();
    if num_pair_str.len() == 3 {
        let num_pair: (i32, i32, i32) = (
            i32::from_str(num_pair_str[0]).expect("failed to parse number"),
            i32::from_str(num_pair_str[1]).expect("failed to parse number"),
            i32::from_str(num_pair_str[2]).expect("failed to parse number"),
        );
        println!("Tuple {:?}", num_pair);
    }
}

有没有一种方法可以避免对数字进行重复解析？

这是一个例子，如果Rust支持类似Python的推导，它可能会看起来像什么：

let num_pair: (i32, i32, i32) = (
    i32::from_str(num_pair_str[i]).expect("failed to parse number")
    for i in 0..3
);

有没有可能以一种扩展向量的方式来声明元组？

- ideasman42

Answer 1

编辑：一个简单的一行代码解决方案：collect_tuple，来自流行的itertools库。

let iter = 1..3;
let (x, y) = iter.collect_tuple().unwrap(); // yeah!

如果你想要更好的IDE类型提示，宏可能不是完美的解决方案。以下是我的建议：

fn tuple1<T>(a: &[T]) -> (&T) { (&a[0]) }
fn tuple2<T>(a: &[T]) -> (&T, &T) { (&a[0], &a[1]) }
fn tuple3<T>(a: &[T]) -> (&T, &T, &T) { (&a[0], &a[1], &a[2]) }
fn tuple4<T>(a: &[T]) -> (&T, &T, &T, &T) { (&a[0], &a[1], &a[2], &a[3]) }
fn tuple5<T>(a: &[T]) -> (&T, &T, &T, &T, &T) { (&a[0], &a[1], &a[2], &a[3], &a[4]) }
fn tuple6<T>(a: &[T]) -> (&T, &T, &T, &T, &T, &T) { (&a[0], &a[1], &a[2], &a[3], &a[4], &a[5]) }

- ch271828n

Answer 2

由于Rust没有类似Python的列表推导式，因此您不能使用它。最接近的方法是通过另一个迭代器明确地执行。您无法直接收集到元组中，因此需要另一种明确的步骤将向量转换为元组：

use std::str::FromStr;

fn main() {
    let some_str = "123,321,312";
    let num_pair_str = some_str.split(',').collect::<Vec<_>>();
    if num_pair_str.len() == 3 {
        let v = num_pair_str.iter().map(|s| i32::from_str(s).expect("failed to parse number"))
            .collect::<Vec<_>>();
        let num_pair: (i32, i32, i32) = (v[0], v[1], v[2]);
        println!("Tuple {:?}", num_pair);
    }
}

如果您想避免中间向量，可以尝试以下方法：

use std::str::FromStr;

fn main() {
    let some_str = "123,321,312";
    let it0 = some_str.split(',');
    if it0.clone().count() == 3 {
        let mut it = it0.map(|s| i32::from_str(s).expect("failed to parse number"));
        let num_pair: (i32, i32, i32) =
            (it.next().unwrap(), it.next().unwrap(), it.next().unwrap());
        println!("Tuple {:?}", num_pair);
    }
}

- starblue

Answer 3

您可以使用类似Iterator::collect的方法声明一个特质，并实现它以收集到不同大小的元组：

fn main() {
    // Example with some simplifications
    // Note that there is no extra allocation
    let num_pair: (i32, i32, i32) = "123,321,312"
        .split(',')
        .map(|s| s.parse().expect("an i32"))
        .try_collect()
        .expect("a 3-tuple of i32");
    assert_eq!(num_pair, (123, 321, 312));
}

trait TryCollect<T> {
    fn try_collect(&mut self) -> Option<T>;
}

macro_rules! impl_try_collect_tuple {
    () => { };
    ($A:ident $($I:ident)*) => {
        impl_try_collect_tuple!($($I)*);

        impl<$A: Iterator> TryCollect<($A::Item, $($I::Item),*)> for $A {
            fn try_collect(&mut self) -> Option<($A::Item, $($I::Item),*)> {
                let r = (try_opt!(self.next()),
                         // hack: we need to use $I in the expasion
                         $({ let a: $I::Item = try_opt!(self.next()); a}),* );
                Some(r)
            }
        }
    }
}

macro_rules! try_opt {
    ($e:expr) => (match $e { Some(e) => e, None => return None })
}

// implement TryCollect<T> where T is a tuple with size 1, 2, .., 10
impl_try_collect_tuple!(A A A A A A A A A A);

其他例子：

fn main() {
    let mut iter = (0..7).into_iter();

    let (a, b, c) = iter.try_collect().unwrap();
    assert_eq!((a, b, c), (0, 1, 2));

    let (d, e) = iter.try_collect().unwrap();
    assert_eq!((d, e), (3, 4));

    let (f,) = iter.try_collect().unwrap();
    assert_eq!(f, 5);

    let a: Option<(u32, u32)> = iter.try_collect();
    assert_eq!(None, a);
}

- malbarbo