主页 / coding / 问题

问题[rust](coding)

Martin Hope
Harry
Asked: 2025-03-24 19:09:34 +0800 CST
  • 5

我如何才能根据值习惯性地将一种Result类型转换为另一种类型？ResultOk

fn get_res1() -> Result<bool, ()> {
    Ok(true)
}

fn get_res2() -> Result<(), String> {
    let res = get_res1().map_err(|err| String::from("Execution failed"))?;

    // map Ok value to Result type(function return type) based on its value
    // Is it possible to combine the below transformation with the above Result type method map_err?
    if !res {
        return Err(String::from("Operation failed"));
    }

    Ok(())
}
rust
Martin Hope
Jet Tang
Asked: 2025-03-24 13:58:32 +0800 CST
  • 6

我正在创建一个具有两个参数的 API 函数，我希望第二个参数的类型取决于第一个参数的值，例如：

enum Component{
   Cpu,
   Disk
}

struct CpuState {
    pub frequency: u64
}

struct DiskState {
    pub speed: u64
}

type Handler<T> = Box<dyn Fn(T) -> Box<dyn Future<Output = String> + Send> + Send + Sync>;

// the type of parameter(`<T>`) in handler is depends on the component you chosen.
fn monitor(component: Component, handler: Handler){}

我尝试过的方法是使用特征，但不起作用：

trait StateEventHandler {
    type Component;
    type Handler;
}

impl StateEventHandler for CpuState {
    type Component = Component::Cpu; // error: expected type, found variant `Component::Cpu`
not a type
    type Handler = Handler<CpuState>;
}

impl StateEventHandler for DiskState {
    type Component = Component::DiskState; // error like above
    type Handler = Handler<DiskState>;
}

fn monitor<T: StateEventHandler>(component: T::Component, handler: T::Handler){}

怎么办呢？

rust
Martin Hope
Dolphin
Asked: 2025-03-23 15:02:48 +0800 CST
  • 6

我想在 rust 中调用 http rpc，但当前上下文是同步的。然后我尝试像这样调用远程 rpc：

 let uniq_id = executor::block_on(get_snowflake_id());

这是get_snowflake_id功能：

use std::env;
use log::error;
use reqwest::Client;
use rust_wheel::model::response::api_response::ApiResponse;

pub async fn get_snowflake_id() -> Option<i64> {
    let client = Client::new();
    let infra_url = env::var("INFRA_URL").expect("INFRA_URL must be set");
    let url = format!("{}{}", infra_url, "/infra-inner/util/uniqid/gen");
    let resp = client
        .get(format!("{}", url))
        .body("{}")
        .send()
        .await;
    if let Err(e) = resp {
        error!("get id failed: {}", e);
        return None;
    }
    let text_response = resp.unwrap().text().await;
    if let Err(e) = text_response {
        error!("extract text failed: {}", e);
        return None;
    }
    let resp_str = text_response.unwrap_or_default();
    let resp_result = serde_json::from_str::<ApiResponse<i64>>(&resp_str);
    if let Err(pe) = resp_result {
        error!("parse failed: {}, response: {}", pe, &resp_str);
        return None;
    }
    Some(resp_result.unwrap().result)
}

但此代码被永久阻止，我在同步上下文中调用异步代码的方法是否正确？我必须这样做，因为上下文是同步的，我无法将当前上下文调用样式更改为异步。我试过：

pub fn get_uniq_id() -> Option<i64> {
    task::block_in_place(|| {
        tokio::runtime::Handle::current().block_on(get_snowflake_id())
    })
}

显示错误 can call blocking only when running on the multi-threaded runtime。这是应用程序入口：

#[actix_web::main]
async fn main() -> std::io::Result<()> {}
rust
Martin Hope
Dolphin
Asked: 2025-03-23 13:25:06 +0800 CST
  • 5

当我在 rust(1.84.0) 模型中使用时，显示错误：

 the trait `types::_::_serde::Deserialize<'_>` is not implemented for `IpNetwork`

但我确实需要反序列化模型，我无法更改 ipnetwork 代码，我该如何解决这个问题？这是依赖项：

ipnetwork = "0.21.1"

这是我定义的模型：

#![allow(unused)]
#![allow(clippy::all)]

use std::fmt::Display;

use serde::Serialize;
use serde::Deserialize;
use crate::model::diesel::dolphin::dolphin_schema::*;
use bigdecimal::BigDecimal;
use chrono::DateTime;
use chrono::offset::Utc;
use ipnetwork::IpNetwork;
#[derive(Insertable,Queryable,QueryableByName,Debug,Serialize,Deserialize,Default,Clone)]
#[diesel(table_name = users)]
pub struct User {
    pub id: i64,
    pub nickname: String,
    pub avatar_url: String,
    pub phone: String,
    pub updated_time: i64,
    pub created_time: i64,
    pub salt: String,
    pub pwd: String,
    pub sex: i32,
    pub level_type: String,
    pub phone_region: String,
    pub country_code: String,
    pub user_status: i32,
    pub last_login_time: Option<i64>,
    pub first_login_time: Option<i64>,
    pub app_id: String,
    pub register_time: i64,
    pub apple_iap_product_id: Option<String>,
    pub auto_renew_product_expire_time_ms: Option<i64>,
    pub is_guest: i32,
    pub product_id: i32,
    pub register_ip: String,
    pub reg_ip: Option<IpNetwork>,
}
rust
Martin Hope
einpoklum
Asked: 2025-03-22 19:37:28 +0800 CST
  • 5

我正在用 Rust 构建以下程序：

fn main() {
    println!("Hello, world!\n");
}

在 Devuan Excalibur 系统上（类似 Debian Trixie，但没有 systemd；rustc 版本 1.84）。构建后（使用cargo build --release），我有：

$ ldd target/release/hello
    linux-vdso.so.1 (0x00007fff356f5000)
    libgcc_s.so.1 => /lib/x86_64-linux-gnu/libgcc_s.so.1 (0x00007f0b073c5000)
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f0b071cf000)
    /lib64/ld-linux-x86-64.so.2 (0x00007f0b0749c000)

这有点奇怪，就像一个 hello-world C 程序一样：

#include <stdio.h>
int main() {
    printf("Hello world\n");
    return 0;
}

和 GCC 14.2（gcc -O3），我得到：

$ ldd hello
    linux-vdso.so.1 (0x00007fff1d573000)
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f8f1649f000)
    /lib64/ld-linux-x86-64.so.2 (0x00007f8f166e5000)

也就是说，没有libgcc_s依赖项。Rust 编译器在需要额外依赖项的可执行文件中放入了什么？为什么？

注意：我首先对可执行文件的大小差异感到疑惑；但这个问题已经解决了。

rust
Martin Hope
Lee
Asked: 2025-03-08 04:51:01 +0800 CST
  • 6

我正在读“这本书”，想测试一下我对章节切片借阅规则的理解。

我对借用检查器如何将我传入的内容与函数返回的内容关联起来（我的假设）印象深刻。所以我尝试了一些示例来测试我的理解，并且我正在努力弄清楚借用检查器的规则。

  1. 为什么test1编译失败，在哪里test5可以找到？
  2. 我的理解哪里错了？（见下面的思考过程）
  3. “这本书”在哪里涵盖了我所不了解的内容？

该代码始终相同：

fn tmp() {
    let mut s = String::from("hello world");

    let thing = testX(&s);

    s.clear(); // error!

    let tmp = thing.len();
    println!("the first word is: {tmp}");
}

测试 1：

fn test1(s: &String) -> &str {
    "Slice"
}

这里我传入了一个可变字符串的不可变引用，但没有在函数中使用它。我返回了一个不同的切片（在我看来，是一个不同的不可变字符串）。我相信一旦test1返回，它就不再持有对 的借用&s。我期望这段代码能够编译，但事实并非如此，我仍然以某种方式持有对 的不可变借用s。

所以我想知道借用检查器是否将返回的类型与传入的类型相关联。

测试2：

fn test2(s: &String) -> Vec<&str> {
    let mut vec = Vec::new();
    vec.push(s.as_str());
    vec
}

我尝试使用更多间接方式来发挥创造力。我不知道as_str()所有权方面有什么用，但我有兴趣了解。在这里，我传回了传入内容的一部分，因此我并不惊讶它无法编译，但我已经怀疑我对规则的理解是错误的。

测试 3

fn test3(s: &String) -> Vec<&str> {
    let mut vec = Vec::new();
    vec.push("Slice");
    vec
}

我遵循了与 类似的原理test1，但也无法编译。这告诉我，它与返回传入类型的引用类型无关，除非它将推理扩展到拥有向量的类型。。？

测试 4

fn test4(s: &String) -> Vec<&usize> {
    let mut vec = Vec::new();
    vec.push(&1);
    vec
}

现在我变得狡猾起来，我创建的代码我认为与 相当test3，但返回的却是不相关的类型。但编译器仍然不允许这样做。所以看起来，由于某种原因，该函数在返回后仍保留着 的借用？！&String

测试 5

fn test5(s: &String) -> Vec<String> {
    let mut vec = Vec::new();
    vec.push(String::from("something new"));
    vec
}

我尝试了这个，完全预料到它也无法编译，但它有效！

test1我认为它在逻辑上与借用相同s。在这两种情况下，我都没有对 做任何事情s，但test1保留借用，而 则test5没有。

帮助！

rust
Martin Hope
ajz34
Asked: 2025-03-06 19:33:51 +0800 CST
  • 5

这是不安全锈蚀中未初始化内存的潜在未定义行为的问题。

  • 首先，通过通常的安全方式分配向量（类型Vec<Vec<usize>>，或者必须是堆而不是堆栈上的某个向量；换句话说，Vec<usize>类型不会在这里引起恐慌）；
  • 第二，在新的范围内克隆向量；
  • 第三，通过不安全的未初始化方式（不使用MaybeUninit）分配一个新的向量；然后发生双重释放。

代码（playground）如下：

#[deny(clippy::uninit_vec)]
unsafe fn uninitialized_vec<T>(size: usize) -> Vec<T> {
    let mut v: Vec<T> = Vec::with_capacity(size);
    unsafe { v.set_len(size) };
    v
}

fn case_1() {
    println!("=== Case 1 ===");
    let vec_a: Vec<Vec<usize>> = vec![vec![0]; 4];
    let _ = vec_a.clone();
    let _: Vec<Vec<usize>> = unsafe { uninitialized_vec(4) };
}

fn case_2() {
    println!("=== Case 2 ===");
    let vec_a: Vec<Vec<usize>> = vec![vec![0]; 4];
    {
        let _ = vec_a.clone();
    }
    let _: Vec<Vec<usize>> = unsafe { uninitialized_vec(4) };
}

fn main() {
    case_1();
    case_2();
}
  • 调试模式：信号 6（SIGABRT）：中止程序，在 tcache 2 中检测到双重释放；case_2将卡在这里；
  • 释放模式：信号4（SIGILL）：非法指令；甚至case_1会卡在这里。

从我的常识来看，代码本身并没有打算对任何变量进行双重释放。我们只是声明了一个未初始化的变量，但没有使用该变量。如果这不是一个错误，那么编译器优化可能是唯一可以解释这个问题的原因。

我很好奇的是：这段代码是否真的会在不安全的 Rust 中触发未定义的行为，编译器优化是否会导致双重释放或其他问题。

  • 如果它实际上是一个 UB，我觉得这段代码确实会让 rust 新手感到困惑（这是我自己说的）。
  • 如果不是UB的话，是不是存在不安全锈蚀的bug？

此外，众所周知，通过MaybeUninit正确使用可以避免这样的双重释放运行时错误：

use std::mem::MaybeUninit;

unsafe fn uninitialized_vec<T>(size: usize) -> Vec<MaybeUninit<T>> {
    let mut v: Vec<MaybeUninit<T>> = Vec::with_capacity(size);
    unsafe { v.set_len(size) };
    v
}

fn main() {
    println!("=== This will not cause error ===");
    let vec_a: Vec<Vec<usize>> = vec![vec![0]; 12];
    {
        let _ = vec_a.clone();
    }
    let _: Vec<MaybeUninit<Vec<usize>>> = unsafe { uninitialized_vec(12) };
}

尽管如此，MaybeUninit在很多情况下还是不方便。主观上，我更喜欢使用Vec<T>而不是Vec<MaybeUninit<T>>，尤其是当我可以确保这个未初始化向量的值稍后会被正确填充时。

rust
Martin Hope
Taro
Asked: 2025-03-06 19:06:50 +0800 CST
  • 5

环境：rustc 1.82.0（f6e511eec 2024-10-15）

问题：Rust 中的解引用与直接借用

*&T我对借用中的和之间的区别感到困惑T。以下代码使用编译let b = &mut *a，但使用编译失败let b = &mut x。为什么在这种情况下*a的行为与不同x？

此外，取消注释最后一行（*b = ...）会导致错误：

无法分配给，*a因为它是借用的

fn annoying_borrow() {
    let mut x = Box::new(1);
    let a = &mut x;
    let b = &mut *a;
    // let b = &mut x; // error: cannot borrow `x` as mutable more than once at a time
    *a = Box::new(2);
    // *b = Box::new(3); // error: `*a` is assigned to here but it was already borrowed
}

这里用*a代替是否进一步暗示了它们之间的细微差别？Emmm，我真正想探究的不是和x之间的区别，而是 Rust 类型系统（编译器）中的借用规则。*ax

背景：

我参考了《Programming Rust》第 2 版（第 5 章），但我无法完全理解这些知识：

共享访问是只读访问。

共享引用借用的值是只读的。在共享引用的整个生命周期中，无论是其引用对象还是从该引用对象可访问的任何对象，都不能被任何对象更改。该结构中不存在任何活动的可变引用，其所有者保持为只读状态，等等。它确实处于冻结状态。

可变访问是独占访问。

可变引用借用的值只能通过该引用访问。在可变引用的整个生命周期中，没有其他可用的路径可以到达其引用对象或任何可从那里访问的值。唯一可能与可变引用生命周期重叠的引用是从可变引用本身借用的引用。

不知道 Rust 中对借用有没有统一详细的解释，也许 Rust 中曾经有一套明确的借用规则，但是随着编译器不断放宽语法限制（为了方便某些场景的编码？），现在的规则就比较混乱了？

rust
Martin Hope
Kyle Carow
Asked: 2025-03-06 12:43:01 +0800 CST
  • 7

我正在编写一个 Rust 板条箱，其中有一个结构体，其字段实现了一个特征，并且我想提供一个功能：

  • #[cfg(not(feature = "dyn"))]：结构字段是T静态分派的（性能更高，但运行时灵活性较差）
  • #[cfg(feature = "dyn")]：结构字段是Box<dyn MyTrait>，动态分派的特征对象（运行时灵活性，性能成本较低）
trait MyTrait {}

#[cfg(not(feature = "dyn"))]
struct MyStruct<T: MyTrait> {
  my_field: T
}

#[cfg(feature = "dyn")]
struct MyStruct {
  my_field: Box<dyn MyTrait>
}

我的问题是，每一个impl块都需要完全复制，但更改只会影响几行。

#[cfg(not(feature = "dyn"))]
impl<T: MyTrait> MyStruct<T> {
    fn new(field: T) -> Self {
        Self { field }
    }
}

#[cfg(feature = "dyn")]
impl MyStruct {
    fn new(field: impl MyTrait + 'static) -> Self {
        Self { field: Box::new(field) }
    }
}

有没有更优雅的方式来做到这一点？宏黑魔法？这只是一个坏主意，不值得做吗？

Rust 游乐场链接

编辑

根据@cdhowie 的回复

这几乎可以成功编译！但是MyTrait实际上有一个方法（我将其删除以获得一个最小示例）：

trait MyTrait: Sized {
  fn calculate(&self, struct: &MyStruct<Self>);
}

&MyStruct<Self>由于此方法需要访问数据进行计算，因此引用是必要的。

尝试按照建议执行，但不起作用……这会破坏动态兼容性

impl MyTrait for Box<dyn MyTrait> {
//               ^^^^^^^^^^^^^^^^
// ERROR
// the trait `MyTrait` cannot be made into an object

如果我尝试实现 Box 的特征（不确定这是否能解决我的问题），那么麻烦就来了：

impl<T: MyTrait> MyTrait for Box<T> {
    fn calculate(
        &self,
        struct: &MyStruct<Self>,
    ) {
        (**self).calculate(struct)
        //                 ^^^^^^
        // ERROR: mismatched types
        // expected reference &MyStruct<T>
        // found reference &MyStruct<Box<T>>

    }
}
rust