问题[rust](coding)

以下是代码：

fn main() {
    let foo: Foo<i32> = Foo(42);
    let bar: Foo<i64> = foo.map_ref(|x| *x as i64); // OK
    let baz: Foo<&i32> = foo.map_ref(|x| x); // Error
}

struct Foo<T>(T);

impl<T> Foo<T> {
    fn map_ref<U, F>(&self, f: F) -> Foo<U>
    where
        F: Fn(&T) -> U,
    {
        Foo(f(&self.0))
    }
}

U引用时编译失败：

error: lifetime may not live long enough
 --> src\main.rs:4:48
  |
4 |     let baz: Foo<&i32> = foo.map_ref(|x: &i32| x); // Error
  |                                          -   - ^ returning this value requires that `'1` must outlive `'2`
  |                                          |   |
  |                                          |   return type of closure is &'2 i32
  |                                          let's call the lifetime of this reference `'1`
  |
help: dereference the return value
  |
4 |     let baz: Foo<&i32> = foo.map_ref(|x: &i32| *x); // Error
  |                                                +

我尝试引入一个通用的生命周期'a但Foo::map_ref不知道下一步该做什么。

我有这样的代码：

use std::fmt::Write;

fn main() {
    let mut side_str = String::new();
    write!(&mut side_str, "world").unwrap();

    println!(
        "hello_{:?}_",
        format!("{:?}", side_str),
        );
}

我在输出中得到了引号。我该如何以简洁的方式编写它以不包含引号？

我正在尝试实现像这个操场上演示的那样的终身标记，但是我在某些地方误入歧途并且无法弄清楚我做错了什么。

这是我遇到的错误。只有当该v.pup(...)行存在时才会出现。

error[E0597]: `arena` does not live long enough
  --> src/lib.rs:65:5
   |
64 |       let arena = goop::Parent;
   |           ----- binding `arena` declared here
65 |       arena.scope(|child, context| {
   |       -^^^^
   |       |
   |  _____borrowed value does not live long enough
   | |
66 | |         let mut v = Foo::new(child);
67 | |         v.pup(context);
68 | |     });
   | |______- argument requires that `arena` is borrowed for `'static`
69 |   }
   |   - `arena` dropped here while still borrowed

这是我的代码，这是我能做到的尽可能简单的代码：

#![no_std]

mod goop {
    use core::marker::PhantomData;

    // Cell<T> is invariant in T; so Cell<&'id _> makes `id` invariant.
    // This means that the inference engine is not allowed to shrink or
    // grow 'id to solve the borrow system. 
    type Id<'id> = PhantomData<::core::cell::Cell<&'id mut ()>>;
    
    #[derive(Clone, Copy)]
    pub struct Child<'id> {
        _id: Id<'id>,
    }
    
    pub struct Parent;
    
    #[derive(Clone, Copy)]
    pub struct Context<'id, 'p> {
        _id: Id<'id>,
        parent: &'p Parent,
    }
    
    impl Parent {
        pub fn scope<'p, F>(&'p self, _f: F)
        where
            F: for<'id> FnOnce(Child<'id>, Context<'id, 'p>)
        {}
        
        fn internal_something(&self) {}
    }
    
    pub trait Gator<C> {
        fn gate(&self, c: C);
    }
    
    impl<'p, 'id> Gator<Context<'p, 'id>> for Child<'id> {
        fn gate(&self, c: Context<'p, 'id>) {
            c.parent.internal_something();
        }
    }
}

use core::marker::PhantomData;

struct Foo<C, G> {
    _c: PhantomData<C>,
    g: G,
}
impl<C, G: goop::Gator<C>> Foo<C, G> {
    fn new(g: G) -> Self {
        Self {
            _c: PhantomData,
            g,
        }
    }
    
    fn pup(&mut self, c: C) {
        self.g.gate(c)
    }
}

fn _check() {
    let arena = goop::Parent;
    arena.scope(|child, context| {
        let mut v = Foo::new(child);
        v.pup(context);
    });
}

操场

我正在尝试使用 cratedocx_rust将 Word 文档列表合并为一个。我尝试了这个，但我遇到了一个问题，doc因为它在循环结束时被丢弃了for。

use docx_rust::{Docx, DocxFile};

fn merge_docs<'a>(file_paths: &[&str], output_path: &str) -> Result<(), Box<dyn std::error::Error>> {
    let mut merged_doc = Docx::default();

    for path in file_paths {
        let doc = DocxFile::from_file(Path::new(path))?;  // No Rc here initially
        let mut p_doc = doc.parse().unwrap();
        merged_doc.document.body.content.extend(p_doc.document.body.content.drain(..));
    }

    merged_doc.write_file(Path::new(output_path))?;

    Ok(())
}

我尝试将每个打开的文档推送到一个向量中，但这并不能延长生命周期。我尝试将它们存储到一个中Rc::new()，但没有成功。

我会欢迎任何解决方案！

这个问题与这里提出的问题有关：如何声明一个变量但不分配它？

我的问题略有不同。MRE：

let var: MyGenericType;
for value in vec_of_values_of_my_generic_type {
    // one of the values is mathematically guaranteed to meet this condition because the vector is special
    if <value meets a certain condition> {
        var = value;
    }
}

<use var>

错误：

error[E0381]: used binding `var` is possibly-uninitialized
   --> example/src/lib.rs:127:23
    |
120 |             let var: MyGenericType;
    |                 -- binding declared here but left uninitialized
...
123 |                     var = value;
    |                     -- binding initialized here in some conditions
...
127 |             foo(var);
    |                       ^^ `var` used here but it is possibly-uninitialized

我该如何修复这个问题？

fn dangle() {
    fn get_str<'a>(s: *const String) -> &'a str {
        unsafe { &*s }
    }
    
    let s = String::from("hello");
    let dangling = get_str(&s);
    drop(s);
    println!("Invalid str: {}", dangling);
}

#[test]
fn test() {
    dangle();  // it should panic, but does not
}

fn main() {
    dangle();  // panics
}

main()正如我所料，该函数崩溃了。但为什么该test()函数能够成功运行？

我有以下 Rust 代码

use std::error::Error;

#[derive(Debug)]
enum MyEnum {
    First,
    Second,
}

fn do_something(index: usize, m: &MyEnum) {
    eprintln!("do_something: {} {:?}", index, m);
}

async fn test() -> Result<(), Box<dyn Error>> {
    let myvec = vec![MyEnum::First, MyEnum::Second];
    let c = String::from("cap");

    let futures = myvec.iter().enumerate().map(|(index, el)| async {
        eprintln!("Element: {}", &c);
        do_something(index, el);
    });

    futures::future::join_all(futures).await;
    Ok(())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    test().await?;
    Ok(())
}

编译器抱怨：

error[E0373]: async block may outlive the current function, but it borrows `index`, which is owned by the current function
  --> src/main.rs:17:62
   |
17 |     let futures = myvec.iter().enumerate().map(|(index, el)| async {
   |                                                              ^^^^^ may outlive borrowed value `index`
18 |         eprintln!("Element: {}", &c);
19 |         do_something(index, el);
   |                      ----- `index` is borrowed here
   |

为什么它没有抱怨变量el？

如何修复此代码？我想继续使用迭代器而不是for循环。我可以更改代码的其他部分，例如do_something()可以有不同的原型。

我把c变量放在这里是为了禁止使用 的简单解决方案async move {...}。字符串c不应该被移动。

没有enumerate()(和没有index) 也可以工作。我期望index(具有usize类型) 可以轻松复制。

我正在尝试生成如下所示的 json 对象

// final json output expected
{
    "j1": {
        "1981": {
            "income": 215
        },
        "1982": {
            "income": 350
        },
    },
    "j2": {
        "1981": {
            "income": 100
        },
        "1982": {
            "income": 215
        },
    }
}

我有以下代码

use serde_json::{Value, Map};

struct s {
    name: String,
    year: i32,
    income: i64
}

fn main() {
    let rows :Vec<s> = vec!(
        s { name: "j1".to_string(), year: 1981, income: 100},
        s { name: "j1".to_string(), year: 1981, income: 115},
        s { name: "j1".to_string(), year: 1982, income: 120},
        s { name: "j1".to_string(), year: 1982, income: 100},
        s { name: "j1".to_string(), year: 1982, income: 130},
        s { name: "j2".to_string(), year: 1981, income: 100},
        s { name: "j2".to_string(), year: 1982, income: 120},
        s { name: "j2".to_string(), year: 1982, income: 130}
    );
    
    let mut data_map: Map<String, Value> = Map::new();
    for row in rows {
        let  mut name: &Map<String, Value> = match data_map.get(&row.name) {
            Some(val) => { &val.as_object().unwrap() },
            None => { &Map::new() }
        };
        let mut year:  &Map<String, Value> = match data_map.get(&row.year.to_string()) {
            Some(val) => { &val.as_object().unwrap() },
            None => { &Map::new() }
        };
        let income: i64 = year.get("income").unwrap_or(&Value::Number(0i64.into())).as_i64().unwrap() + row.income;
        year.insert("income".to_string(), Value::Number(income.into()));
    }
}

我创建了这个代码来提问。我还咨询了 deepseek 等

我收到的错误消息是

error[E0596]: cannot borrow `*year` as mutable, as it is behind a `&` reference
  --> src\main.rs:32:9
   |
32 |         year.insert("income".to_string(), Value::Number(income.into()));
   |         ^^^^ `year` is a `&` reference, so the data it refers to cannot be borrowed as mutable
   |
help: consider changing this binding's type
   |
27 |         let mut year: &mut serde_json::Map<std::string::String, Value> = match data_map.get(&row.year.to_string()) {
   |                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

显然我对引用和借用理解不足。如能得到任何帮助我将不胜感激。

在下面的代码中，如果我注释掉println!匹配表达式后的语句，就会出现借用检查器相关的问题。为了解决这个问题，编译器要求我在表达式末尾添加一个分号，match这解决了这个问题，但我不明白这样做的必要性。

use std::sync::{Arc, Mutex};

#[derive(Default)]
struct A {
    b: Arc<Mutex<B>>,
}

#[derive(Default)]
struct B {
    c: Arc<Mutex<C>>,
}

#[derive(Default)]
struct C {
    d: i32,
}

fn main() {
    let a = A::default();
    
    match a.b.lock().unwrap().c.lock().unwrap().d {
        0 => println!("zero"),
        _ => println!("non-zero"),
    }
    // uncommenting the below line makes borrow checker happy
    // println!("{}", a.b.lock().unwrap().c.lock().unwrap().d);
}

错误

error[E0597]: `a.b` does not live long enough
  --> src/main.rs:21:11
   |
19 |     let a = A::default();
   |         - binding `a` declared here
20 |     
21 |     match a.b.lock().unwrap().c.lock().unwrap().d {
   |           ^^^----------------
   |           |
   |           borrowed value does not live long enough
   |           a temporary with access to the borrow is created here ...
...
27 | }
   | -
   | |
   | `a.b` dropped here while still borrowed
   | ... and the borrow might be used here, when that temporary is dropped and runs the `Drop` code for type `MutexGuard`
   |
help: consider adding semicolon after the expression so its temporaries are dropped sooner, before the local variables declared by the block are dropped
   |
24 |     };
   |      +

For more information about this error, try `rustc --explain E0597`.

我正在尝试为 Cargo 指定一个自定义运行器，但它就是拒绝使用它。我尝试使用我自己的自定义目标三元组target.，也尝试使用您在下面看到的 cfg 选项：

[target.'cfg(all(target_os = "none"))']
runner = "qemu-system-riscv64 -machine virt -kernel "

但在这两种情况下，它都说我在编译时有一个未使用的清单键：

warning: unused manifest key: target.cfg(all(target_os = "none")).runner

使用时cargo run它总是只运行普通二进制文件而不是我的自定义运行器。

我的情况比较特殊，因为我使用文件夹config.toml下的文件.cargo来指定我的自定义目标三元组：

[unstable]
build-std-features = ["compiler-builtins-mem"]
build-std = ["core", "compiler_builtins"]

[build]
target = "compilation_targets/riscv-unknown-kadrix.json"

由于这是一个内核，因此它有一些特殊之处：

• 不使用标准库
• 不使用主函数，其入口点是_start
• 使用自定义.start部分_start来代替.text
• 使用自定义测试框架

不确定这些要点是否相关，但谨慎一点总比后悔好。如果您想进一步检查，代码在这里。