小编caf*_*e25的帖子

我刚刚开始学习 Rust，遇到了HashMap 的 entry() 方法看似奇怪的行为。在下面的示例中，该方法采用可变引用并返回Entry 枚举。我什至没有捕获并保留返回的值。但是借用检查器似乎认为下一次迭代开始时对“s”的可变引用仍然在范围内。

let mut window: HashMap<&String, i32> = HashMap::new();
let mut s = "help_me".to_string();
loop {
    let p = &mut s;        // ERROR
    window.entry(p);
}

这显示了片段恐慌并出现错误：

Line 27, Char 26: cannot borrow `s` as mutable more than once at a time (solution.rs)
   |
27 |             window.entry(&mut s);
   |                          ^^^^^^ `s` was mutably borrowed here in the previous iteration of the loop

有人可以向我解释一下这种行为吗？

我一直在尝试制作一个功能类似于Python输入函数的宏。

而不是每次我想要稍微自动化它时都完全编写标准输入，并结合 println！这样我就可以用一块石头杀死两只鸟。

本质上，如果有人传入一个参数，它会打印一个字符串，然后要求输入，如果他们不这样做，它只会要求从终端输入。

#[macro_export]
macro_rules! input {
    ($a:expr) => {
        println!("{}", $a);
        let mut input = String::new();
        std::io::stdin().read_line(&mut input).unwrap();

        return $input
    };

    (_) => {
        let mut input = String::new();
        std::io::stdin().read_line(&mut $input).unwrap();

        return $input
    };
}

我在 let 语句上不断收到错误，只是不知道如何继续，因为我不太了解宏语法。

我发布了整个代码块，因为在第二个匹配表达式上，我试图在没有参数的情况下进行匹配，但我不确定我是否做得正确。

有时错误消息将我带到 github 页面，并且遇到随机错误，所以我只是困惑如何继续进一步

如果有人能帮助我修复 let 语句，我将不胜感激，对于给您带来的任何不便，我深表歉意。

我写了如下代码，可以编译成功，

#[tokio::main]
async fn main() {

}

但我很好奇为什么mainproc_macro 可以直接使用而不需要任何前奏或显式的 use 语句？

我在 Haskell 中有三个函数。所有这些都旨在基于 n 次迭代的初始猜测来执行 \xe2\x88\x9a2 。

\n
1. \n

   squareRootTwo :: Double -> Integer -> Double\nsquareRootTwo guess n\n| n == 0 = guess\n| otherwise = squareRootTwo ((guess + 2/guess) / 2) (n-1)\n

   Run Code Online (Sandbox Code Playgroud)\n
\n
2. \n

   squareRootTwoA :: Double -> Integer -> Double\nsquareRootTwoA guess n\n| n == 0 = guess\n| otherwise = squareRootTwoA ((guess + 2/guess) / 2) (n-1) where n=n\n

   Run Code Online (Sandbox Code Playgroud)\n
\n
3. \n

   squareRootTwoB :: Double -> Integer -> Double\nsquareRootTwoB guess n\n| n == 0 = guess\n| otherwise = …

   Run Code Online (Sandbox Code Playgroud)

我用 Rust 编程才几个月。话虽这么说，我遇到了一条警告，内容如下：

warning: value assigned to `amount` is never read
   --> src\execute_action_functions.rs:428:21
    |
428 |             let mut amount: Option<f64> = None;
    |                     ^^^^^^
    |
    = help: maybe it is overwritten before being read?

为了清楚起见并避免意外错过关键细节，整个函数如下：

pub async fn handle_all_gemini(prefix: &str, message: &str, shared_neural_network: Arc<Mutex<NeuralNetwork>>, divisor: &f64) {


    if prefix.contains("Gemini received") {
        if message.contains("heartbeat") {
            return;
        }
        else {
            let data: Result<Value, serde_json::Error> = serde_json::from_str(message);

            let mut amount: Option<f64> = None;
            let mut price: Option<f64> = None;

            match data {
                Ok(value) …

我想在异步 fn 中使用递归，就像：

async fn test(data: i32) -> i32 {
    if data == 0 {
        0
    } else {
        test(data - 1).await
    }
}

但它说 an 中的递归async fn需要装箱。

所以我把它改成这样：

async fn test(data: i32) -> BoxFuture<'static, i32> {
    async move {
        if data == 0 {
            0
        } else {
            test(data - 1).await.await
        }
    }
    .boxed()
}

但它再次编译错误，并显示消息：计算类型时使用的循环，test::{opaque#0} 我应该做什么来修复它？

我正在编写一个属性宏并尝试解析那里传递的参数。

喜欢：#[macro(Arg1, Arg2)]

问题是我找不到正确的结构来解析它。我尝试将其解析为MetaandMetaList但它们似乎都不起作用。

pub fn some_macro(args: TokenStream, item: TokenStream) -> TokenStream {
let args_parsed = parse_macro_input!(args as MetaList);

////////

let args_parsed = parse_macro_input!(args as Meta);

}

当我解析它时，MetaList我得到：“意外的输入结束，预期的括号”错误。

我想使用概念来区分一维和二维容器。我的第一次尝试如下：

template<typename C>
concept Container1D = requires(C c) {
    std::begin(c);
    std::end(c);
    c[0];
};

template<typename C>
concept Container2D = requires(C c) {
    std::begin(c);
    std::end(c);
    c[0, 0]; // interpreted as comma-operator
};

但显然这不起作用，因为表达式0, 0被解释为逗号运算符，因此第二个概念也匹配一维容器。

有没有办法要求二维operator[a, b]？

PartialEq我有一个在切片中实现的类型的元素序列。为了便于说明，我们假设它看起来像这样：

let data = [1,1,1,2,2,3,4,5,5,5,5,6];

我想迭代这个序列的借用切片，以便这些切片的所有元素都相等PartialEq。例如，在上面的切片中，data我想要一个迭代器，它会产生：

&data[0..3]   // [1,1,1]
&data[3..5]   // [2,2]
&data[5..6]   // [3]
&data[6..7]   // [4]
&data[7..11]  // [5,5,5,5]
&data[11..12] // [6]

看起来slice::group_by正是我所需要的，但从 Rust 1.72.0 开始，它还不稳定。是否有任何简单的方法可以通过使用第 3 方板条箱或结合使用稳定的 std lib API 以稳定的方式获得此功能？

我用 Rust 编写了一个简单的程序。这个程序可以编译。

use std::cell::{Ref, RefCell};

fn print_number(x: &i32) {
    println!("x is {}", x);
}

fn main() {
    let stack: i32 = 42;
    let reference: &i32 = &stack;
    let refcell: RefCell<&i32> = RefCell::new(reference);
    let wrapped: Ref<'_, &i32> = refcell.borrow();

    print_number(&wrapped);
    print_number(*wrapped);
}

我可以说出两者都有效的原因：

1. &有效，因为&wrapped的类型为&Ref<&i32>，可以被解引用强制为&&i32，也可以被解引用强制为&i32。
2. *有效，因为*wrapped相当于*Deref::deref(&wrapped). 我们知道Deref::deref(&Ref<&i32>)结果为&&i32，因此*Deref::deref(&Ref<&i32>)结果为*&&i32，即&i32。

似乎第二种方法（使用*）更直接，但是 Rust 编译器建议我使用第一种方法（使用&）。如果我添加一行：

print_number(wrapped);

这当然不能编译。但我对编译器报告感兴趣：

error[E0308]: …