BallpointBen's questions

我有一个宏，它包装了对的多个调用write!。举个例子，假设我们有这个宏：

use std::fmt::Write;

macro_rules! write_twice {
    ($writer:expr, $($fmt:tt)*) => {{
        (|| {
            for _ in 0..2 {
                if let err @ ::core::result::Result::Err(_) = write!($writer, $($fmt)*) {
                    return err;
                }
            }
            Ok(())
        })()
    }};
}

fn main() {
    let v = vec![1, 2];
    let mut buf = String::new();
    write_twice!(&mut buf, "{v:?}").unwrap();
    println!("{buf:?}");  // [1, 2][1, 2]
}

现在，我想正确捕捉作者，但我正在努力让它在所有情况下都发挥作用。即：

1. 如果传递了一个表达式，则应该只对其进行一次求值，这样就可以正常write_twice(fs::File::create(path)?, args...)工作而无需第二次写入重新截断文件。
2. 宏调用之后，编写器应该仍然可用，即$writer不应被移动。
3. 如果 的实例可以write!(w, args...)编译，那么在替换 时它也应该可以编译write_twice!(w, args...)。

write_twice!现在，上述失败 #1的版本write!($writer, $($fmt)*)将被评估两次。我们可以用以下代码替换它：

macro_rules! write_twice {
    ($writer:expr, $($fmt:tt)*) => {{
        (|| {
            let mut writer = $writer;  // evaluate only once
            for _ in 0..2 {
                if let err @ ::core::result::Result::Err(_) = write!(writer, $($fmt)*) {
                    return err;
                }
            }
            Ok(())
        })()
    }};
}

但这违反了 #2 因为 a&mut T不是Copy：

use std::fmt;

struct Double(String);

impl fmt::Display for Double {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "first -> ")?;
        write_twice!(f, "{}", self.0)?;
        write!(f, " <- second")  // borrow of moved value: `f`
    }
}

error[E0382]: borrow of moved value: `f`
  --> src/main.rs:23:10
   |
5  |         (|| {
   |          -- value moved into closure here
...
20 |     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
   |                   - move occurs because `f` has type `&mut Formatter<'_>`, which does not implement the `Copy` trait
21 |         write!(f, "first -> ")?;
22 |         write_twice!(f, "{}", self.0)?;
   |                      - variable moved due to use in closure
23 |         write!(f, " <- second")
   |                ^ value borrowed here after move

因此我尝试用 替换该行let writer = &mut $writer;以避免移动&mut T，但现在我们收到一个新的编译器错误，违反了 #3（尽管编译器的建议确实解决了该问题）：

error[E0596]: cannot borrow `f` as mutable, as it is not declared as mutable
  --> src/main.rs:6:17
   |
6  |             let writer = &mut $writer;
   |                          ^^^^^^^^^^^^ cannot borrow as mutable
...
22 |         write_twice!(f, "{}", self.0)?;
   |         ----------------------------- in this macro invocation
   |
   = note: this error originates in the macro `write_twice` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider changing this to be mutable
   |
20 |     fn fmt(&self, mut f: &mut fmt::Formatter<'_>) -> fmt::Result {
   |                   +++

如果我们尝试let mut writer = &mut *$writer，我们将无法再调用，write_twice!(string, ...)因为我们现在尝试写入 a&mut str而不是 a &mut String。

那么，在多次写入的宏中捕获写入器的正确方法是什么？

HashMap<&String, V>使用索引的正确方法是什么&str？Rust 报告&String不是Borrow<str>，这是索引所必需的。（这对我来说似乎有点傻；如果T: Borrow<U>那么肯定&T: Borrow<U>也应该成立？）

use std::collections::HashMap;

fn main() {
    let strings = vec!["x".to_owned(), "y".to_owned(), "z".to_owned()];
    let m = [0, 1, 2]
        .into_iter()
        .map(|i| (&strings[i], i))
        .collect::<HashMap<&String, usize>>();
    let zero = m["x"];
}

error[E0277]: the trait bound `&String: Borrow<str>` is not satisfied
 --> src/main.rs:9:18
  |
9 |     let zero = m["x"];
  |                  ^^^ the trait `Borrow<str>` is not implemented for `&String`, which is required by `HashMap<&String, usize>: Index<&_>`
  |
  = help: the trait `Borrow<str>` is implemented for `String`
  = help: for that trait implementation, expected `String`, found `&String`
  = note: required for `HashMap<&String, usize>` to implement `Index<&str>`

显然，因为我构建了这个特定的 HashMap，所以我可以返回并将其键类型更改为&str。但是，假设我得到了一个HashMap<&String, V>，那么对其进行索引的正确方法是什么？构建一个整体String只是为了引用它似乎很浪费。

在 Rust 中，是否可以使用模式匹配[T; k]从 a 的第一个k元素构造 a [T; n]？我想避免这种情况：

// k = 3 here
let [c1, c2, c3, ..] = my_array;
let front = [c1, c2, c3];

而是做这样的事情（虚构的语法）：

let front: [T; 3];
[..front, ..] = my_array;
// or...
let [..front: [T; 3], ..] = my_array;
// or...
let [front @ [_; 3], ..] = my_array;

这样的事情可能吗？