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),
          _ => ()
}

所以，我的问题：

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

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(", "));
}

这仅针对特定大小的元组实现我们的特性，对于某些情况可能没问题，但肯定不是酷。 standard library使用了一些宏来减少为获得更多尺寸而需要做的复制和粘贴的苦差事。我决定甚至更懒惰并减少该解决方案的复制和粘贴！

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

Answer 2

other answer给了我很多帮助，因为一旦你使用了递归和模式匹配，它就清楚地说明了Rust的简单宏系统的强大功能。

我已经设法做了一些粗略的改进（可能能够使模式更简单，但它相当棘手）在它之上，以便元组访问器 - ＆gt;类型列表由宏反转在扩展到trait实现之前编译时间，这样我们就不再需要在运行时调用.rev()，从而提高效率：

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

macro_rules! tuple_impls {
    () => {}; // no more

    (($idx:tt => $typ:ident), $( ($nidx:tt => $ntyp:ident), )*) => {
        /*
         * Invoke recursive reversal of list that ends in the macro expansion implementation
         * of the reversed list
        */
        tuple_impls!([($idx, $typ);] $( ($nidx => $ntyp), )*);
        tuple_impls!($( ($nidx => $ntyp), )*); // invoke macro on tail
    };

    /*
     * ([accumulatedList], listToReverse); recursively calls tuple_impls until the list to reverse
     + is empty (see next pattern)
    */
    ([$(($accIdx: tt, $accTyp: ident);)+]  ($idx:tt => $typ:ident), $( ($nidx:tt => $ntyp:ident), )*) => {
      tuple_impls!([($idx, $typ); $(($accIdx, $accTyp); )*] $( ($nidx => $ntyp), ) *);
    };

    // Finally expand into the implementation
    ([($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 = vec![self.$idx.to_string(), $( self.$nidx.to_string() ),*];
                parts.join(sep)
            }
        }
    }
}

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

#[test]
fn test_join_tuple() {
    let a = ( 1.3, 1, 'c' );

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

如何迭代或映射元组？

2 个答案: