是否有可能在不分配新Vec的情况下将一个功能映射到一个Vec上？

Question

我有以下内容:

enum SomeType {
    VariantA(String),
    VariantB(String, i32),
}

fn transform(x: SomeType) -> SomeType {
    // very complicated transformation, reusing parts of x in order to produce result:
    match x {
        SomeType::VariantA(s) => SomeType::VariantB(s, 0),
        SomeType::VariantB(s, i) => SomeType::VariantB(s, 2 * i),
    }
}

fn main() {
    let mut data = vec![
        SomeType::VariantA("hello".to_string()),
        SomeType::VariantA("bye".to_string()),
        SomeType::VariantB("asdf".to_string(), 34),
    ];
}

我现在想在data的每个元素上调用变换，并将结果值存储回data中。我可以做类似data.into_iter（）. map（变换）. Collection（）的事情，但这将分配一个新的Vec。有没有一种方法可以就地执行此操作，重用data的分配内存？Rust中曾经有Vec::map_in_place，但它已经被删除了一段时间。

作为解决方法，我向 SomeType 添加了一个虚拟变体，然后执行以下操作：

for x in &mut data {
    let original = ::std::mem::replace(x, SomeType::Dummy);
    *x = transform(original);
}

这感觉不对，我必须处理代码中其他任何地方的＜code＞SomeType：：Dummy＜/code＞问题，尽管它不应该在这个循环之外可见。有没有更好的方法？

Answer 1

您可以根据< code>take_mut或< code>replace_with板条箱编写< code>map_in_place:

fn map_in_place<T, F>(v: &mut [T], f: F)
where
    F: Fn(T) -> T,
{
    for e in v {
        take_mut::take(e, f);
    }
}

但是，如果此在提供的函数中死机，程序将完全中止;你无法从恐慌中恢复过来。

或者，您可以提供一个占位符元素，该元素在内部函数执行时位于空位置：

use std::mem;

fn map_in_place_with_placeholder<T, F>(v: &mut [T], f: F, mut placeholder: T)
where
    F: Fn(T) -> T,
{
    for e in v {
        let mut tmp = mem::replace(e, placeholder);
        tmp = f(tmp);
        placeholder = mem::replace(e, tmp);
    }
}

如果出现恐慌，您提供的占位符将位于恐慌状态。

最后，您可以按需生成占位符；在第一个版本中，基本上将take_mut:：take替换为。

Answer 2

不，通常不可能，因为每个元素的大小可能会随着映射的执行而改变（fn-transform（u8）-

即使大小相同，这也不是微不足道的。

在这种情况下，您不需要创建虚拟变体，因为创建空字符串很便宜;只有 3 个指针大小的值，没有堆分配：

impl SomeType {
    fn transform(&mut self) {
        use SomeType::*;

        let old = std::mem::replace(self, VariantA(String::new()));

        // Note this line for the detailed explanation

        *self = match old {
            VariantA(s) => VariantB(s, 0),
            VariantB(s, i) => VariantB(s, 2 * i),
        };
    }
}

for x in &mut data {
    x.transform();
}

一个替代实现，只是替换字符串：

impl SomeType {
    fn transform(&mut self) {
        use SomeType::*;

        *self = match self {
            VariantA(s) => {
                let s = std::mem::replace(s, String::new());
                VariantB(s, 0)
            }
            VariantB(s, i) => {
                let s = std::mem::replace(s, String::new());
                VariantB(s, 2 * *i)
            }
        };
    }
}

一般来说，是的，你必须创建一些虚拟值，用安全的代码来做这些。很多时候，可以将整个元素包装在< code>Option中，调用< code>Option::take来达到同样的效果。

另请参阅：

• 将字段移动到新变量时更改枚举变量

请参阅这个提议的现已关闭的RFC，了解大量相关讨论。我对RFC(及其背后的复杂性)的理解是，在一段时间内，您的值将具有未定义的值，这是不安全的。如果在那一秒发生了紧急情况，那么当您的值被丢弃时，您可能会触发未定义的行为，这是一件坏事。

如果您的代码在注释行处出错，那么< code>self的值是一个具体的已知值。如果它是某个未知值，删除该字符串将尝试删除该未知值，我们又回到了c中。这就是< code>Dummy值的目的——总是存储一个已知良好的值。

你甚至暗示了这一点（我的重点）：

我必须处理SomeType：:D ummy在代码中的其他地方，尽管它不应该在这个循环之外可见。

“应该”是问题所在。在恐慌期间，这个虚拟值是可见的。

另请参阅：

< li >如何为结构的可变引用中的字段换入新值？ < li >暂时移出借用的内容 < li >如何移出作为选项的结构字段？

现在删除的 Vec：：html" target="_blank">map_in_place 实现跨越了近 175 行代码，其中大部分必须处理不安全的代码，并推理为什么它实际上是安全的！一些板条箱重新实施了这一概念，并试图使其安全;你可以在Sebastian Redl的答案中看到一个例子。

Answer 3

第一个问题不是映射，而是变换。

transform拥有其参数的所有权，而Vec拥有其参数的所有权。任何一个都必须付出，在Vec上戳一个洞将是一个坏主意：如果转型恐慌怎么办？

因此，最好的解决方法是将< code>transform的签名改为:

fn transform(x: &mut SomeType) { ... }

然后你可以做:

for x in &mut data { transform(x) }

其他解决方案将是笨拙的，因为它们需要处理变换可能会恐慌的事实。