问题[rust]

如何修正代码以避免错误：
'a', 'b' -- is borrowed here
returns a value referencing data owned by the current function？

use std::collections::HashMap;

#[derive(Debug)]
struct Error;

fn f1(s: &str) -> Result<&str, Error> { 
   // something for test:
   if s.len() > 5 {
      Ok(s)
   }else{
      Err(Error)
   }      
}

fn f2(s: &str) -> Result<&str, Error> { 
   todo!() 
}



fn r(raw: HashMap<String, String>) -> Result<HashMap<&'static str, &'static str>, Error> {
    raw
        .into_iter()
        .map(|(a, b)| {
            
            // println!("{:?} - {:?}", a, b);
            Ok((
                f1(&a)?,
                f2(&b)?,
            ))
        })
        .collect()
}



fn main() {
    let raw: HashMap<String, String> = HashMap::from([
       ("Mercury".to_string(), "0.4".to_string()),
       ("Venus".to_string(), "0.7".to_string()),
       ("Earth".to_string(), "1.0".to_string()),
       ("Mars".to_string(), "1.5".to_string()),
    ]);
    
    println!("{:?}", r(raw));
}

下面两行在[A]应用程序代码[B]中给出相同的结果，即
可以互换并且应用程序可以正常运行。
我理解的是否正确：
第一个将签名转移到变量，即第二个函数本身foo
- 将函数工作的结果传递给变量foo

1. 如何从文档中输出 JoinHandle 的内容和主题行：
   fn from(join_handle: crate::thread::JoinHandle<T>) -> OwnedHandle {}

use std::thread;

fn foo() -> usize {
   88
}
    
fn main() {
    
   let h1: thread::JoinHandle<_> = thread::spawn(foo);             // [A]
   let h2: thread::JoinHandle<_> = thread::spawn(move || foo());   // [B]

   println!("h1 = {:?}", h1);
   println!("h2 = {:?}", h2);
}

播放

h1 = JoinHandle { .. }
h2 = JoinHandle { .. }

2. 那么如何在下面的例子中做类似的事情，以便它能够工作g2而不是g2()：
   play_2

fn foo() -> usize {
   88
}

fn f<T>(z: T) -> T {
   z
}

fn main() {
    
   let g1 = f(foo());
   println!("g1 = {:?}", g1);
    
   let g2 = f(foo);
   // println!("g2 = {:?}", g2); <- ?
   assert_eq!(g1, g2());

   // или 

   let v1 = foo;
   let v2 = foo();
   // println!("v1 = {:?}", v1);
   println!("v1 = {:?}", v1());
   println!("v2 = {:?}\n", v2);
}

第一个块中给出的代码有效。
如何将其放入impl创建单独线程的单独部分中？
就像第二个代码块一样，其中注意到так не работает.
播放_1

use std::time::{SystemTime, Instant};
use std::thread;
use thread::JoinHandle;


fn main() {

   let handle: JoinHandle<(usize, SystemTime, SystemTime, core::time::Duration)> = thread::spawn(|| {
      let t21: SystemTime = SystemTime::now();
      let start_02 = Instant::now();
      let mut j: usize = 0;
      loop {
         if j == 10 { break; }
         j = j + 1;
      }
      let t22: SystemTime = SystemTime::now();
      let d2:(usize, SystemTime, SystemTime, core::time::Duration) = (j, t21, t22, start_02.elapsed());
      d2
   });

   
   let t11: SystemTime = SystemTime::now();
   let start_01 = Instant::now();
   let mut i: usize = 0;
   loop {
      if i == 10 { break; }
      i = i + 1;
   }
   let t12 = SystemTime::now();

   
   let d2 = handle.join().expect("thread panicked :...");

   println!("i = {:?} \nt11 = {:?} \nt12 = {:?}", i, t11, t12);
   println!("dt_01 = {:?}\n", start_01.elapsed());
   //
   println!("j = {:?} \nt21 = {:?} \nt22 = {:?}", &d2.0, &d2.1, &d2.2);
   println!("dt_02 = {:?}\n", &d2.3);
}

像这样的东西：
play_2

use std::time::{SystemTime, Instant};
use std::thread;
use thread::JoinHandle;

struct Thd {
   a: usize, 
   b: SystemTime, 
   c: SystemTime,
   d: core::time::Duration,
}

impl Thd {

   pub fn new() -> JoinHandle<(usize, SystemTime, SystemTime, core::time::Duration)> {

     thread::spawn(|| {
       let t21: SystemTime = SystemTime::now();
       let start_02 = Instant::now();
       let mut j: usize = 0;
       loop {
         if j == 1_000_000 { break; }
         j = j + 1;
       }
       let t22: SystemTime = SystemTime::now();
       
       let d: Thd = Thd01 {a: j, b: t21, c: t22, d:start_02.elapsed()};
       
       let d2:(usize, SystemTime, SystemTime, core::time::Duration) = (d.a, d.b, d.c, d.d);

       d2
     });
   }
}

fn main() {
   // Error `так не работает`:
   let handle: JoinHandle<(usize, SystemTime, SystemTime, core::time::Duration)> = Thd::new();

   
   let t11: SystemTime = SystemTime::now();
   let start_01 = Instant::now();
   let mut i: usize = 0;
   loop {
      if i == 1_000_000 { break; }
      i = i + 1;
   }
   let t12 = SystemTime::now();

   
   let d2 = handle.join().expect("thread panicked :...");

   println!("i = {:?} \nt11 = {:?} \nt12 = {:?}", i, t11, t12);
   println!("dt_01 = {:?}\n", start_01.elapsed());
   //
   println!("j = {:?} \nt21 = {:?} \nt22 = {:?}", &d2.0, &d2.1, &d2.2);
   println!("dt_02 = {:?}\n", &d2.3);
}

播放_3

use std::time::{SystemTime, Instant};
use std::thread;
use thread::JoinHandle;

struct Thd {
   a: usize, 
   b: SystemTime, 
   c: SystemTime,
   dt: core::time::Duration,
}

impl Thd {

   pub fn new() -> JoinHandle<(usize, SystemTime, SystemTime, core::time::Duration)> {
   
     let handle: JoinHandle<(usize, SystemTime, SystemTime, core::time::Duration)> =
     thread::spawn(|| {
       let t21: SystemTime = SystemTime::now();
       let start_02 = Instant::now();
       let mut j: usize = 0;
       loop {
         if j == 1_000_000 { break; }
         j = j + 1;
       }
     
       let t22: SystemTime = SystemTime::now();
       let d: Thd = Thd {a: j, b: t21, c: t22, dt:start_02.elapsed()};
       let d2:(usize, SystemTime, SystemTime, core::time::Duration) = (d.a, d.b, d.c, d.dt);
       d2
     });
     handle
   }
}

fn main() {
   // `так работает`:
   let handle: JoinHandle<(usize, SystemTime, SystemTime, core::time::Duration)> = Thd::new();

   
   let t11: SystemTime = SystemTime::now();
   let start_01 = Instant::now();
   let mut i: usize = 0;
   loop {
      if i == 1_000_000 { break; }
      i = i + 1;
   }
   let t12 = SystemTime::now();

   
   let d2 = handle.join().expect("thread panicked :...");

   println!("i = {:?} \nt11 = {:?} \nt12 = {:?}", i, t11, t12);
   println!("dt_01 = {:?}\n", start_01.elapsed());
   //
   println!("j = {:?} \nt21 = {:?} \nt22 = {:?}", &d2.0, &d2.1, &d2.2);
   println!("dt_02 = {:?}\n", &d2.3);
}

/*

i = 1000000 
t11 = SystemTime { tv_sec: 1737389697, tv_nsec: 383198522 } 
t12 = SystemTime { tv_sec: 1737389697, tv_nsec: 385890160 }
dt_01 = 2.931694ms

j = 1000000 
t21 = SystemTime { tv_sec: 1737389697, tv_nsec: 383252593 } 
t22 = SystemTime { tv_sec: 1737389697, tv_nsec: 386045474 }
dt_02 = 2.792891ms

*/

我正在使用reqwest来执行请求。

这是curl 中的一个请求：

curl --request POST --data '{"role_id":"222","secret_id":"444"}' https://vault.main.ru/v1/auth/approle/login

它的外观和工作方式如下：

let url_login = "https://vault.main.ru/v1/auth/approle/login";
let client = reqwest::Client::new();
    
    let json_data = r#"{"role_id":"222","secret_id":"444"}"#;
    let response = client
        .post(url_login)
        .header("Content-Type", "application/json")
        .body(json_data.to_owned())
        .send()
        .await?;

如何使用reqwest执行这样的curl 请求？

curl --header "X-Vault-Token: sdf33422323" --request LIST https://vault.main.ru/v1/secretsstream/metadata

LIST - 据我了解，这是一种自定义方法。怎么传送呢？

大家好，我遇到了一个问题——完全缺乏工作教程。我发现的 inkwell (llvm) 和 Cranelift 都是 5-6 年前无法使用的矿渣。不知何故，神奇的是，对于作者（例如）模块来说，它是一种结构，而对我来说，它是一种特质。

实际上，这就是为什么我要求您帮助我找到使用上述库之一的教程或新示例。