小编Her*_*tar的帖子

我有一个元组向量：

let v = vec![(1, 1), (1, 1), (1, 3), (1, 4), (2, 2), (2, 4), (2, 6)];

我想把它分成两个列表。第一个列表包含每个元组中的第一个元素，第二个列表包含第二个元素，即：

l1 = [1, 1, 1, 1, 2, 2]和l2 = [1, 1, 3, 4, 2, 4]。

我怎样才能做到这一点？

我目前有一个主要应用程序，其中的某些部分可以“实时修补”。例如。一些具有预定义名称和签名的函数可以在运行时更新。目前，重新修补是通过以下两个步骤执行的：

• 使用 std::process::Command 调用 rustc 从源代码编译 cdylib。每个输出文件都有一个新名称，以确保 dlopen 不会使用缓存的旧文件
• 使用 libloading 加载并运行新修补的函数

由于几个原因，这显然并不理想。我的问题是是否有更好的方法来实现这一目标？例如，从 Rust 内部进行编译。

附加信息：

• 补丁文件不需要任何外部 crate
• 补丁文件需要了解一些常见的库模块，这些模块不会实时修补

我正在拼凑一些东西，列出我的 Windows 盒子上的每个窗口，并且似乎（仅）对于我的一个窗口 GetWindowRect 返回一个具有非常负的 y 坐标的矩形。

可能的复杂情况：(1) 我有多个显示器，但 (1a) y 坐标非常负，约为 -24000，并且 (1b) 两个显示器上的其他窗口不显示此效果；(2) 我正在使用 VirtuaWin 虚拟桌面工具，但 (2a) 其他窗口，在多个不同的虚拟桌面和两台显示器上，不显示此效果；(3) 我使用 pywin32 模块在 Python 中完成所有这些工作。

相关窗口是 Windows 资源管理器窗口。它的大小或位置并不异常（至少从肉眼看来）。当前活动虚拟桌面上的资源管理器窗口不会显示此行为，但是当我在其他虚拟桌面上创建资源管理器窗口时，它们会显示相同的意外效果。

我运行的是 Windows XP 和 VirtuaWin 4.3 版本。

发生什么了？

我想将此 Python 代码转换为 Rust：

for line in sys.stdin:
   do something to the whole line including \n

但我只能找到读取单个整行（包括\n）的示例或不读取\n.

看起来这应该是世界上最简单的，但我一直找不到它。

我有以下 Rust 代码，它模拟了一个配置文件，其中包含一个HashMap带有enum.

use std::collections::HashMap;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
enum Source {
    #[serde(rename = "foo")]
    Foo,
    #[serde(rename = "bar")]
    Bar
}

#[derive(Debug, Clone, Serialize, Deserialize)]
struct SourceDetails {
    name: String,
    address: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
struct Config {
    name: String,
    main_source: Source,
    sources: HashMap<Source, SourceDetails>,
}

fn main() {
    let config_str = std::fs::read_to_string("testdata.toml").unwrap();
    match toml::from_str::<Config>(&config_str) {
        Ok(config) => println!("toml: {:?}", config),
        Err(err) => eprintln!("toml: {:?}", err),
    }

    let …

我试图了解 Rust 的生命周期如何影响结构。附件是一个让我困惑的最小例子。

我想给一个结构体一个对象的引用，然后需要更改这个对象。由于借用对象时无法更改该对象，因此我认为必须在更改对象时删除引用。所以我的想法是将变量定义为一个选项，并在修改对象期间通过将其设置为 来删除引用None。对于不使用结构的示例，这似乎可行。但是，如果我现在将此引用放入结构中，它将不起作用。在我看来，借用检查器忽略了变量string不再被借用的事实。有没有办法仍然通过结构实现所需的行为？

这有效（链接到游乐场）：

fn main() {
    let mut string = "mutable string".to_string();
    let mut ref_to_string: Option<&str> = Some(&string);
    ref_to_string = None;
    string = "mutated string".to_string();
    ref_to_string = Some(&string);
}

但是，这不起作用链接到游乐场：

struct Foo<'a> {
    pub ref_data: Option<&'a str>,
}

fn main() {
    let mut string = "mutable string".to_string();
    let mut foo = Foo{ref_data: Some(&string)};
    foo.ref_data = None;
    string = "mutated string".to_string();
    foo.ref_data = Some(&string);
}

错误信息：

error[E0506]: cannot assign to …

假设我有一个很大的 JSON 文件。我的目标是删除该 JSON 中的嵌套字段并写入一个新文件。

use serde_json::Value;
use serde_json::Map;

fn main() {
    let data = r#"{
                    "name": "John Doe",
                    "age": 43,
                    "nested":{
                        "to.be.removed": [
                          "+44 1234567",
                          "+44 2345678"
                        ],
                        "other": "important fields"

                    }
                  }"#;

    let mut map :Map<String, Value> =serde_json::from_str(data).expect("failed to read file");
    // how do i remove  "to.be.removed"?


}

操场

我不知道如何删除这样的嵌套属性。

由于 json 非常复杂，我必须坚持使用 Map，因为我对结构不感兴趣。获取嵌套的值会呈现出一个Value. 我只想将值更改为地图，然后像这样插入 map.insert(String::from("nested"), nested);。

有谁知道如何从配置文件而不是环境中创建 Rust 中的 aws_config 。大多数示例使用以下内容来创建 aws_config

let shared_config = aws_config::from_env().region(region_provider).load().await;

就我而言，凭证是动态创建的并存储在 .aws/credentials 中。您能分享一段演示此功能的代码片段吗？

谢谢

TL；博士。是否可以为已经具有特征所需的所有方法的现有类型自动实现特征？

长版。假设我想要一个通用函数，可以对任何类似堆栈的类型执行堆栈操作。所以我有一个特点

pub trait StackLike<T> {\n    fn is_empty(&self) -> bool;\n    fn pop(&mut self) -> Option<T>;\n    fn push(&mut self, value: T);\n}\n

我现在可以这样使用pub fn foo(s: &mut dyn StackLike<i32>) { s.push(42); }：到目前为止，一切都很好。

有几种现有类型已经满足我的特征，因此实现它很简单，例如

impl<T> StackLike<T> for Vec<T> {\n    fn is_empty(&self) -> bool { self.is_empty() }\n    fn pop(&mut self) -> Option<T> { self.pop() }\n    fn push(&mut self, value: T) { self.push(value) }\n}\n\nimpl<T, const N: usize> StackLike<T> for SmallVec<[T; N]> {\n    fn is_empty(&self) -> bool …

在下面的代码中：

enum Either<A, B> { Left(A), Right(B) }

use Either::{Left, Right};

impl<A, B> From<A> for Either<A, B> {
    fn from(a: A) -> Self {
        Left(a)
    }
}

impl<A, B> From<B> for Either<A, B> {
    fn from(b: B) -> Self {
        Right(b)
    }
}

我收到以下错误：“std::convert::From<_>类型特征的实现冲突Either<_, _>”。From<A>我不明白和From<B>for的实现Either<A, B>是如何冲突的。

我在标准库文档中看到了一个示例，其中他们所做的几乎与我正在做的完全一样，但它在那里工作：

use std::fs;
use std::io;
use std::num;

enum CliError {
    IoError(io::Error),
    ParseError(num::ParseIntError),
}

impl From<io::Error> for CliError {
    fn from(error: io::Error) -> Self { …