rust编译器在多大程度上自动匹配泛型约束？

Question

#[derive(Debug)]
struct Binary_Tree_Node<T: PartialOrd + Clone> {
    left: Binary_Tree<T>,
    value: T,
    right: Binary_Tree<T>
}

#[derive(Debug)]
struct Binary_Tree<T: PartialOrd + Clone> {
    node: Option<Box<Binary_Tree_Node<T>>> 
}

impl <T: PartialOrd + Clone>Binary_Tree<T> {
    fn new(value_to_insert: T) -> Binary_Tree<T> {
        Binary_Tree{node: 
            Some(
                Box::new(
                    Binary_Tree_Node{
                        left: Binary_Tree{node: None}, 
                        value: value_to_insert, 
                        right: Binary_Tree{node: None}
                    }
                )
            )
        }
    }

    fn map<F, U>(&self, f: F) -> Option<U> 
    where F: FnOnce(&Binary_Tree_Node<T>) -> U {
        self.node.as_ref().map(|node| f(&**node))
        // equivalent 
        //self.node.as_ref().map(|node| f(node))
    }
}
let mut test1 = Binary_Tree::new(10);
println!("{:#?}", test1.map(|node| node.value < 2));

self.node.as_ref().map(|node| f(node))

因为我希望rust抛出编译器错误

self.node的类型为Option<Box<Binary_Tree_Node<T>>>

self.node.as_ref()的类型为Option<&Box<Binary_Tree_Node<T>>>

self.node.as_ref().map(|node| f(node))中的node的类型为&Box<Binary_Tree_Node<T>>

问题是为什么self.node.as_ref().map(|node| f(&**node))和self.node.as_ref().map(|node| f(node))都能工作？

Answer 1

这是一种“德雷夫胁迫”，参见nomicon Coercions

允许在以下类型之间进行

强制：

• ...
• Deref强制:如果&x指向U (即T: Deref<Target=U>)

)，则将&T类型的表达式&*x转换为&U类型的T

Box<T>实现了Deref<Target=T>，因此&Box<T>会自动强制转换为&T，就像您编写&*node一样。

(我不确定"Expression &x“部分中的&是用来做什么的，因为我们在强制站点上没有&，它仍然可以工作--可能是打字错误或bug)

也适用于从&String到&str：Playground

fn foo<T>(_v: T) {}

fn main() {
    {
        let v: &Box<i32> = &Box::new(5i32);
        foo::<&i32>(v);
        foo::<&i32>(&*v);
    }

    {
        let v: &String = &String::from("abc");
        foo::<&str>(v);
        foo::<&str>(&*v);
    }
}