Deref

Deref 是 deref 操作符 * 的 trait，比如 *v。

一般理解，*v 操作，是 &v 的反向操作，即试图由资源的引用获取到资源的拷贝（如果资源类型实现了 Copy），或所有权（资源类型没有实现 Copy）。

Rust 中，本操作符行为可以重载。这也是 Rust 操作符的基本特点。本身没有什么特别的。

强制隐式转换（coercion）

Deref 神奇的地方并不在本身 解引 这个意义上，Rust 的设计者在它之上附加了一个特性：强制隐式转换，这才是它神奇之处。

这种隐式转换的规则为：

一个类型为 T 的对象 foo，如果 T: Deref<Target=U>，那么，相关 foo 的某个智能指针或引用（比如 &foo）在应用的时候会自动转换成 &U。

粗看这条规则，貌似有点类似于 AsRef，而跟 解引 似乎风马牛不相及。实际里面有些玄妙之处。

Rust 编译器会在做 *v 操作的时候，自动先把 v 做引用归一化操作，即转换成内部通用引用的形式 &v，整个表达式就变成 *&v。这里面有两种情况：

  1. 把其它类型的指针（比如在库中定义的，Box, Rc, Arc, Cow 等），转成内部标准形式 &v；
  2. 把多重 & （比如：&&&&&&&v），简化成 &v（通过插入足够数量的 * 进行解引）。

所以，它实际上在解引用之前做了一个引用的归一化操作。

为什么要转呢？ 因为编译器设计的能力是，只能够对 &v 这种引用进行解引用。其它形式的它不认识，所以要做引用归一化操作。

使用引用进行过渡也是为了能够防止不必要的拷贝。

下面举一些例子：

  1. fn foo(s: &str) {
  2.     // borrow a string for a second
  3. }
  5. // String implements Deref<Target=str>
  6. let owned = "Hello".to_string();
  8. // therefore, this works:
  9. foo(&owned);

因为 String 实现了 Deref<Target=str>。

  1. use std::rc::Rc;
  3. fn foo(s: &str) {
  4.     // borrow a string for a second
  5. }
  7. // String implements Deref<Target=str>
  8. let owned = "Hello".to_string();
  9. let counted = Rc::new(owned);
  11. // therefore, this works:
  12. foo(&counted);

因为 Rc<T> 实现了 Deref<Target=T>。

  1. fn foo(s: &[i32]) {
  2.     // borrow a slice for a second
  3. }
  5. // Vec<T> implements Deref<Target=[T]>
  6. let owned = vec![1, 2, 3];
  8. foo(&owned);

因为 Vec<T> 实现了 Deref<Target=[T]>。

  1. struct Foo;
  3. impl Foo {
  4.     fn foo(&self) { println!("Foo"); }
  5. }
  7. let f = &&Foo;
  9. f.foo();
  10. (&f).foo();
  11. (&&f).foo();
  12. (&&&&&&&&f).foo();

上面那几种函数的调用，效果是一样的。

coercion 的设计，是 Rust 中仅有的类型隐式转换，设计它的目的，是为了简化程序的书写，让代码不至于过于繁琐。把人从无尽的类型细节中解脱出来，让书写 Rust 代码变成一件快乐的事情。