为什么Rust无法在类型构造函数中将可变引用强制为不可变引用？

Question

可以将&mut T强制转换为&T，但如果在类型构造函数中发生类型不匹配，则无法使用。

https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=648dd22adce90d86169d4f82ceeedcde

use ndarray::*; // 0.13.0

fn print(a: &ArrayView1<i32>) {
    println!("{:?}", a);
}

pub fn test() {
    let mut x = array![1i32, 2, 3];
    print(&x.view_mut());
}

对于上面的代码，我得到以下错误：

  |
9 |     print(&x.view_mut());
  |           ^^^^^^^^^^^^^ types differ in mutability
  |
  = note: expected reference `&ndarray::ArrayBase<ndarray::ViewRepr<&i32>, ndarray::dimension::dim::Dim<[usize; 1]>>`
             found reference `&ndarray::ArrayBase<ndarray::ViewRepr<&mut i32>, ndarray::dimension::dim::Dim<[usize; 1]>>`

将&mut i32强制转换为&i32是安全的，为什么在这种情况下不使用它？您能否提供一些有关事与愿违的例子？

Answer 1

考虑此检查是否有一个空字符串，该空字符串在content函数的运行时依赖于is_empty保持不变（仅出于说明目的，请勿在生产代码中使用此字符串）：

struct Container<T> {
    content: T
}

impl<T> Container<T> {
    fn new(content: T) -> Self
    {
        Self { content }
    }
}

impl<'a> Container<&'a String> {
    fn is_empty(&self, s: &str) -> bool
    {
        let str = format!("{}{}", self.content, s);
        &str == s
    }
}

fn main() {
    let mut foo : String = "foo".to_owned();
    let container : Container<&mut String> = Container::new(&mut foo);

    std::thread::spawn(|| {
        container.content.replace_range(1..2, "");
    });

    println!("an empty str is actually empty: {}", container.is_empty(""))
}

(Playground)

由于&mut String不强制转换为&String，因此无法编译此代码。但是，如果这样做，则可能是新创建的线程在content调用之后但在format!函数中的相等比较之前更改了is_empty，从而使容器内容是不可变的假设无效，空支票是必需的。

Answer 2

通常来说，将Type<&mut T>强制转换为Type<&T>听起来并不合理。

例如，考虑此包装器类型，该包装器的实现没有任何不安全的代码，因此是合理的：

#[derive(Copy, Clone)]
struct Wrapper<T>(T);

impl<T: Deref> Deref for Wrapper<T> {
    type Target = T::Target;
    fn deref(&self) -> &T::Target { &self.0 }
}

impl<T: DerefMut> DerefMut for Wrapper<T> {
    fn deref_mut(&mut self) -> &mut T::Target { &mut self.0 }
}

此类型具有&Wrapper<&T>自动取消引用&T，&mut Wrapper<T>自动取消引用&mut T的属性。另外，如果Wrapper<T>是，则T是可复制的。

假设存在一个可以将&Wrapper<&mut T>强制转换为&Wrapper<&T>的函数：

fn downgrade_wrapper_ref<'a, 'b, T: ?Sized>(w: &'a Wrapper<&'b mut T>) -> &'a Wrapper<&'b T> {
    unsafe {
        // the internals of this function is not important
    }
}

通过使用此功能，可以同时获取对相同值的可变且不变的引用：

fn main() {
    let mut value: i32 = 0;

    let mut x: Wrapper<&mut i32> = Wrapper(&mut value);

    let x_ref: &Wrapper<&mut i32> = &x;
    let y_ref: &Wrapper<&i32> = downgrade_wrapper_ref(x_ref);
    let y: Wrapper<&i32> = y_ref.clone();

    let a: &mut i32 = &mut *x;
    let b: &i32 = &*y;

    // these two lines will print the same addresses
    // meaning the references point to the same value!
    println!("a = {:p}", a); // e.g. ""
    println!("b = {:p}", b); // e.g. ""
}

Full playground example

在Rust中不允许这样做，这会导致未定义的行为，并且在这种情况下，函数downgrade_wrapper_ref不正确。在某些特定情况下，作为程序员，您可以保证不会发生这种情况，但是仍然需要您使用unsafe代码专门针对这些情况来实现，以确保您有责任这些保证。