rust - 使用函数时对自动取消引用规则的混淆

Question

假设我们已经知道 String 在 deref for 之后可以变成 &str

impl ops::Deref for String {
    type Target = str;

    #[inline]
    fn deref(&self) -> &str {
        unsafe { str::from_utf8_unchecked(&self.vec) }
    }
}

• 这段代码可以工作是因为有一个解引用链:&String --> String ---> &str。

  fn uppercase(s: &str) -> String {
      s.to_uppercase()
  }
  
  fn main() {
      let s = String::from("hello");
      assert_eq!(uppercase(&s), "HELLO");
  }
  

• 为什么下面的代码不能工作，即使有一个 deref 链 String ---> &str？

  fn uppercase(s: &str) -> String {
      s.to_uppercase()
  }
  
  fn main() {
      let s = String::from("hello");
      assert_eq!(uppercase(s), "HELLO");
  }
  

• 为什么下面的代码不工作，即使有一个 deref 链:&String --> String？

  fn uppercase(s: String) -> String {
      s.to_uppercase()
  }
  
  fn main() {
      let s = String::from("hello");
      assert_eq!(uppercase(&s), "HELLO");
  }
  

引用

• Why does String implicitly convert to &str in Rust?
• What are Rust's exact auto-dereferencing rules?

Answer 1

来自 The Rust Programming Language :

Deref coercion is a convenience that Rust performs on arguments to functions and methods. Deref coercion works only on types that implement the Deref trait. Deref coercion converts such a type into a reference to another type. For example, deref coercion can convert &String to &str because String implements the Deref trait such that it returns &str. Deref coercion happens automatically when we pass a reference to a particular type’s value as an argument to a function or method that doesn’t match the parameter type in the function or method definition. A sequence of calls to the deref method converts the type we provided into the type the parameter needs.

Deref 强制将引用转换为引用。它会将 &value 自动解引用为 &*value, &**value, &***value,等等，以便将一种引用类型转换为适合参数签名的另一种引用类型。开始和结束类型始终是引用。

值得注意的是，它没有将 deref 放在前面。它不会将 &value 转换为 *&value 为 **&value，这就是为什么它不会转换 &String 到 String 或 String 到 &str。

• 将 &String 变成 String 会把它变成一步棋。如果我编写了 func(&s) 并且 func 接受了一个 String 如果编译并实际移动了 s 将会造成混淆>.

• 类似地，将 String 转换为 &str 会将移动转换为按引用传递。如果我写了 func(s)，我希望 s 被移动，所有权转移给 func。如果 func 接受一个 &str 而我传递一个 String，它不应该编译。