小编dan*_*nda的帖子

我需要在运行时构建一个 json 对象。现在，只是一个简单的 {"key": "stringvalue"} 对象。但每个键/值对必须添加到循环中。

这看起来非常简单/基本，但我没有找到任何好的示例或文档。我终于设法让一些东西发挥作用，但它似乎太复杂了，不是正确的方法。

任何人都可以发布一个工作示例吗？

to_owned()状态的文档：

从借用的数据创建拥有的数据，通常是通过克隆。

但是没有说明不会发生克隆的条件。“通常”很模糊，出于性能原因，我试图删除 clone() 调用。

有人可以澄清吗？

这是我制作的一个小示例程序：

type Index = usize;
type ValType = u32;

#[derive(Debug)]
pub struct NewVec(pub Vec<ValType>);

impl IntoIterator for NewVec {
    type Item = (Index, ValType);
    type IntoIter = <Vec<(Index, ValType)> as IntoIterator>::IntoIter;

    fn into_iter(self) -> Self::IntoIter {
        self.0
            .into_iter()
            .enumerate()
            .collect::<Vec<_>>()
            .into_iter()
    }
}

fn main() {
    let v = vec![100];
    let new_v = NewVec(v.clone());
    
    println!("Vec::into_iter:    {:?}", v.into_iter());
    println!("NewVec::into_iter: {:?}", new_v.into_iter());
    
}

该程序正确运行，并生成以下输出：

Vec::into_iter:    IntoIter([100])
NewVec::into_iter: IntoIter([(0, 100)])

然而 NewVec::into_iterator 调用collect()来创建一个新的Vec，然后调用它的into_iter()。

我的目标是消除对collect()的调用并直接返回一个迭代器。我希望避免不必要的分配。

这可能吗？

请注意，如果我们删除对 .collect() 的调用，我们会收到此错误：

error[E0308]: mismatched types
  --> src/main.rs:12:9 …

我的输入是文件系统路径的平面列表，这些路径都是单个顶级目录的子目录（或其中的文件）。

我的最终输出应该是：

\n
1. 路径的文本分层显示，类似于 UNIX树命令。
\n
2. 具有与 (1) 匹配的逻辑结构的路径的分层 JSON 序列化
\n

我创建了一个中间数据结构，它是一个自引用，具有名称和\'ed childstruct Dir向量。Boxstruct Dir

我可以成功地Dir用来表示任意目录树，如下面的输出所示。

我正在考虑使用堆栈来处理列表，Dir为每个子目录添加一个并在升序时弹出，但我似乎无法像使用 C 或其他语言那样使用 Rust。无论我尝试什么，我都会遇到编译器错误。

如何将平面列表转换为 aDir并使编译器满意？或者，如何以不同的方式实现（1）和（2）？

代码：

// A type to represent a path, split into its component parts\n#[derive(Debug)]\nstruct Path {\n    parts: Vec<String>,\n}\nimpl Path {\n    pub fn new(path: &str) -> Path {\n        Path {\n            parts: path.to_string().split("/").map(|s| s.to_string()).collect(),\n        }\n    }\n}\n\n// A recursive type to …

我有一个如下所示的函数：

    fn set_many(&mut self, key_vals: impl IntoIterator<Item = (Index, T)>)
    {
        let (keys, vals): (Vec<_>, Vec<_>) = key_vals.into_iter().unzip();

        let mut viter = vals.into_iter();
        let mut iter_mut = self.many_iter_mut(keys);

        while let Some(mut setter) = iter_mut.next() {
            setter.set(viter.next().unwrap())
        }
    }

fn main() {
    let mut v = SimpleVec(vec![100, 200, 300, 400, 500]);
    
    v.set_many([(1, 20), (2, 30), (4, 50)]);
    
    println!("modified vec: {:?}", v);
}

输出：

modified vec: SimpleVec([100, 20, 30, 400, 50])

这是可行的，但有必要调用unzip()将键和值收集到单独的 Vec 中。对于大型集合来说，这是不可取的。

更改函数签名并接受单独的 key 和 val iter 参数将起作用。不幸的是，这个函数是公共 …

我的目标是使用NewType(Arc<RwLock<Vec<T>>>)一个many_iter_mut()返回迭代器的方法来创建一个迭代器，该迭代器RwLockWriteGuard在内部Vec<T>.

因此，写锁将由ManyIterMut迭代器保持，直到迭代器被删除。这与为每次调用获取写锁不同ManyIterMut::next()。（我已经在其他地方工作过）

这对于使调用者能够同时设置许多元素并读取许多元素非常有用，但是以原子方式进行的。这样读者总是会看到从一批写入到下一批写入的一致视图。（我之前的 implManyIterMut未通过并发测试。）

ManyIterMut::next()问题是由于生命周期问题我无法编译该方法。编译器似乎不喜欢 the 由write_lockthe 拥有，ManyIterMut而不是由LockedVec正在迭代的 which 拥有。

这里是游乐场。

产生错误的代码是：

impl<'a, V, T: 'a> LendingIterator for ManyIterMut<'a, V, T>
where
    V: StorageVecWrites<T> + ?Sized,
    V::LockedData: StorageVecReads<T>,
    T: Copy,
{
    type Item<'b> = StorageSetter<'b, V, T>
    where
        Self: 'b;

    // This is the fn that won't compile.
    //
    // we can't change the fn signature, it …