如何迭代或映射元组？

Question

我最初的问题是将不同类型的元组转换为字符串.在Python中,这将是这样的:

>> a = ( 1.3, 1, 'c' )
>> b = map(  lambda x:  str(x), a )
['1.3', '1', 'c']

>> " ".join(b)
'1.3 1 c"

然而,Rust不支持元组上的映射 - 仅支持类似矢量的结构.显然,这是因为能够将不同类型打包成元组并且缺少函数重载.此外,我找不到在运行时获取元组长度的方法.所以,我想,需要一个宏来进行转换.

首先,我尝试匹配元组的头部,例如:

// doesn't work
match some_tuple {
    (a, ..) => println!("{}", a),
          _ => ()
}

所以,我的问题:

1. 是否可以使用库函数将元组转换为字符串,指定任意分隔符？
2. 如何编写一个宏,以便能够将函数映射到任意大小的元组？

Answer 1

这是一个过于聪明的宏观解决方案:

trait JoinTuple {
    fn join_tuple(&self, sep: &str) -> String;
}

macro_rules! tuple_impls {
    () => {};

    ( ($idx:tt => $typ:ident), $( ($nidx:tt => $ntyp:ident), )* ) => {
        impl<$typ, $( $ntyp ),*> JoinTuple for ($typ, $( $ntyp ),*)
        where
            $typ: ::std::fmt::Display,
            $( $ntyp: ::std::fmt::Display ),*
        {
            fn join_tuple(&self, sep: &str) -> String {
                let parts: &[&::std::fmt::Display] = &[&self.$idx, $( &self.$nidx ),*];
                parts.iter().rev().map(|x| x.to_string()).collect::<Vec<_>>().join(sep)
            }
        }

        tuple_impls!($( ($nidx => $ntyp), )*);
    };
}

tuple_impls!(
    (9 => J),
    (8 => I),
    (7 => H),
    (6 => G),
    (5 => F),
    (4 => E),
    (3 => D),
    (2 => C),
    (1 => B),
    (0 => A),
);

fn main() {
    let a = (1.3, 1, 'c');

    let s = a.join_tuple(", ");
    println!("{}", s);
    assert_eq!("1.3, 1, c", s);
}

基本的想法是我们可以取一个元组并将其解压缩成一个&[&fmt::Display].一旦我们有了这个,就可以直接将每个项目映射到一个字符串中,然后将它们全部与一个分隔符组合在一起.这就是它自己的样子:

fn main() {
    let tup = (1.3, 1, 'c');

    let slice: &[&::std::fmt::Display] = &[&tup.0, &tup.1, &tup.2];
    let parts: Vec<_> = slice.iter().map(|x| x.to_string()).collect();
    let joined = parts.join(", ");

    println!("{}", joined);
}

下一步是创建一个特征并为特定情况实现它:

trait TupleJoin {
    fn tuple_join(&self, sep: &str) -> String;
}

impl<A, B, C> TupleJoin for (A, B, C)
where
    A: ::std::fmt::Display,
    B: ::std::fmt::Display,
    C: ::std::fmt::Display,
{
    fn tuple_join(&self, sep: &str) -> String {
        let slice: &[&::std::fmt::Display] = &[&self.0, &self.1, &self.2];
        let parts: Vec<_> = slice.iter().map(|x| x.to_string()).collect();
        parts.join(sep)
    }
}

fn main() {
    let tup = (1.3, 1, 'c');

    println!("{}", tup.tuple_join(", "));
}

这只针对特定大小的元组实现了我们的特性,对于某些情况可能没什么问题,但肯定不是很酷.该标准库使用了一些宏来减少你需要做的就是更多尺寸的复制和粘贴的苦差事.我决定更懒惰,减少该解决方案的复制和粘贴!

我没有清楚明确地列出每个大小的元组和相应的索引/通用名称,而是使我的宏递归.这样,我只需要列出一次,所有较小的大小只是递归调用的一部分.不幸的是,我无法弄清楚如何让它朝前进的方向前进,所以我只是将所有东西翻转并向后移动.这意味着我们必须使用反向迭代器,效率很低,但这应该是一个很小的代价.