fn main() {
    // i passed a reference to a value of type i32
    print_type_of(&1); // but print: i32

    // but if i pass a double reference
    print_type_of(&&1); // it print &i32, not &&i32

    // i passed a referece to a value of type i32
    print_type_of_without_ampersand(&1); // now print: &i32 as expected

    referece_pattern(&1); // it works!

    // -> update <-

    // if i have
    let x = 1;
    let ref_x = &&x;

    // this is the implementation of Deref for &T
    // #[stable(feature = "rust1", since = "1.0.0")]
    // #[rustc_const_unstable(feature = "const_deref", issue = "88955")]
    // impl<T: ?Sized> const Deref for &T { //! -> here T should be &&i32 or &i32 ? <- !
    //     type Target = T;

    //     #[rustc_diagnostic_item = "noop_method_deref"]
    //     fn deref(&self) -> &T { // if here self is &&i32, and T should be &&i32 too
    //         *self // <- here  after deference self should be &i32, but &T is still &&i32 that is incompatible <- !
    //     }
    // }
    // -> end update <-
}

// amperand is before the type name
// so it should not be a reference pattern
fn print_type_of<T>(_: &T) {
    println!("{}", std::any::type_name::<T>())
}

fn print_type_of_without_ampersand<T>(_: T) {
    println!("{}", std::any::type_name::<T>())
}

// reference pattern happens here
// amperand is before the parameter name
fn referece_pattern(&x: &i32) {
    assert!(x == 1);
    println!("it works!");
}

我也读过这篇关于引用模式的文章，但是它没有解释这一点。
更新：我在代码中添加了新内容，关于&T的Deref实现