小编Fin*_*ber的帖子

我正在努力掌握do notationHaskell 中的内容。

我可以将它与 Maybe 一起使用，然后打印结果。像这样：

maybeAdd :: Maybe Integer
maybeAdd = do one <- maybe1
              two <- maybe2
              three <- maybe3
              return (one + two + three)

main :: IO ()
main = putStr (show $ fromMaybe 0 maybeAdd)

但是，我没有使用单独的函数，而是尝试在主函数中使用带有 Maybe 的 do 表示法。但我没有任何运气。我尝试的各种尝试包括：

main :: IO ()
main = do one <- maybe1
          two <- maybe2
          three <- maybe3
          putStr (show $ fromMaybe 0 $ return (one + two + three))

main :: IO ()
main …

我知道非阻塞 IO 不会阻塞调用线程，而是在等待 IO 时释放它来做其他事情。

我刚刚了解了Thread. yield允许线程告诉 CPU 运行其他线程的方法......技术上产生控制。

这两个东西，非阻塞 IO 和Thread. yield听起来和我很相似，所以我想知道，在最基本的层面上，非阻塞 IO 是Thread. yield在做 IO 时才使用的吗？

我看到当enumerate被调用时，该index值以usize. 为什么是这样？我怎样才能让它返回索引作为另一种数字类型？比如说u32？

现在我必须手动转换为u32. 例如：

let mut even_index: Vec<u32> = Vec::new();
for (i, v) in vec![10,27,31,40,5].iter().enumerate() {
    if v % 2 == 0 {
        even_index.push(i as u32); // any way to avoid this?
    }
}

有没有办法不必手动执行转换u32并enumerate返回索引u32？

我查看了这里的文档，文档包含以下内容：

enumerate() 将其计数保留为 usize。如果您想按不同大小的整数进行计数，zip 函数提供类似的功能。

我查看了该zip函数，看起来它做了一些不同的事情，所以我不明白为什么当需要按不同大小的整数进行计数时建议将其作为替代方案。

正如标题所说，我可以正确地说 Clone 用于在堆上复制，而 Copy 用于在 Rust 中的堆栈上复制吗？

这基本上就是这篇文章所说的内容，但我对其正确性表示怀疑。

好的，我有一个 axum 处理程序，看起来有点像这样：

#[debug_handler]
async fn handler(
    State(server_state): State<Arc<Server>>,
    Query(query_params): Query<Query>,
) -> impl IntoResponse {
    match server_state.store.handle(query_params).await {
        Ok(res) => (StatusCode::OK, Json(res)),
        Err(err) => (StatusCode::INTERNAL_SERVER_ERROR, Json(err))
    }
}

此操作失败并出现以下错误：

   |
42 | /     match server_state.store.handle(query_params).await {
43 | |         Ok(res) => (StatusCode::OK, Json(res)),
   | |                   -------------------------- this is found to be of type `(StatusCode, axum::Json<Vec<Data>>)`
44 | |         Err(err) => (StatusCode::INTERNAL_SERVER_ERROR, Json(err))
   | |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected struct `Vec`, found enum `sqlx::Error`
45 | |     }
   | |_____- `match` arms …

我认为我想做的事情很简单，但是通读有关网络的 docker compose 文档部分https://docs.docker.com/compose/networking/我发现没有有用的信息:(

我想创建 2 个子网（将来可能会更多 - 但现在我们只创建两个子网），并且能够手动将每个子网的 IP 地址分配给我在 docker-compose 中指定的容器。

如何才能做到这一点？

我对 Rust 的学习让我了解了动态大小类型 (DST)，并且我知道这些类型的大小在编译时无法得知。例如str。

我现在的问题是，我说 DST 永远不会存在于堆栈上，它们只存在于堆上，这样说对吗？

另外，另一方面，说大小类型可以存在于堆栈中是否正确：

(eg. let x:u32 = 10)

但也可以存在于堆上，例如通过使用 Box

(eg let x: Box<u32> = Box::new(10))

上述这些说法是否正确？

我试图理解RustClone和CopyRust 之间的区别。谷歌搜索我看到的答案似乎可以归结为：Clone专为任意重复而设计，而Copy代表可以通过memcpy.

所有这些答案的问题在于所有参考都memcpy假设读者知道什么memcpy

但对于像我这样不确定的人来说，memcpy因为我没有 C/C++ 经验，所以不确定这如何帮助解释复制和克隆之间的区别。

有人可以帮助解释复制memcpy和克隆之间的区别吗？特别是如何提及它？

所以我试图测试我是否理解生命周期，并想创建一个在编译时失败的场景。我想出的代码如下：

#[test]
fn lifetime() {

    struct Identity<'a> {
        first_name: &'a str
    }
    
    let name: Identity;

    {
        let first: &str = "hello";

        name = Identity {
            first_name: first
        };
    }

    println!("{}", name.first_name);
}

推理是 的实例Identity应该与引用的一样长first_name。

let first: &str = "hello"然后在我使用较小范围创建的代码中，将其设置为let name: Identity;，然后在first应该超出范围之后，我尝试打印name.first_name. 我原以为这不会编译，但它编译得很好。

我对生命周期如何工作以及为什么要编译的理解中缺少什么？

＃编辑

更新代码以使其编译失败：

        let string = String::from("hello");
        let first: &str = string.as_str();

仍然好奇为什么原始代码有效。

所以我想定义一些模块lib.rs但不公开它们，但只能在项目中使用。

在 my 中lib.rs，如果我有这样的定义：

pub mod args;

在我的中main.rs，我可以args这样使用模块：

use my_lib::args::Cli;

其中my_lib定义Cargo.tml为

[lib]
name = "my_lib"
path = "src/lib.rs"

但我不想pub mod args;。我尝试更改为，pub(crate) mod args;但这会导致编译错误，args无法找到模块。

如何使args定义的模块lib.rs可用而不需要给予它最宽松的可见性？

只是玩弄 Arc 和 Mutex，我发现该join方法仅显示在类型值上Arc<Mutex<i32>>，而不是Arc<i32>直接使用时显示。

    let counter = Arc::new(Mutex::new(0));
    counter.lock() // method exists and returns LockResult<MutexGuard<'_, T>>

    // but
    let counter = Arc::new(0);
    counter.lock() // method does not exist

我本以为lock是给定第一个示例的方法Arc，但似乎该方法仅在Arc包装 a时出现Mutex

什么类型的机器允许这种情况发生？