Provide a function to compare pointers and references for equality

[RalfJung]

Currently, Rust lacks a nice way to compare two values of type &T or Cell<T> for identity of references (as opposed to identity of the stored values). With a, b having type &T, one has to write a as *const _ == a as *const _, which is not exactly discoverable nor nice to look at.

We (eddyb, kimundi and me) discussed this on IRC, kimundi made the following proposal:

 fn ptr_eq<T>(a: *const T, b: *const T) -> bool { a == b }

Thanks to coercions, in the above scenario, we can now write "ptr_eq(a, b)". eddyb was opposed to a function providing "reference" equality on &T, due to the difference of references in Rust and other languages (in particular, involving zero-sized types).

I think some nice way of comparing pointers (references) for equality should be provided, that does not force the user to manually write down a cast to a "dangerous" raw pointer (though of course the usage above is completely safe).

[bluss]

ptr_eq is very useful due to type inference and coercions. I had a tiresome comparison of *mut T to &T and this function coerces both sides correctly unlike plain ==.

The ptr_eq function also makes sure you compare pointers with the same destination type.

[Columbus240]

At the moment I use as_unsafe_cell() of RefCell to do the same thing. It works in my use-case because the data is already enclosed in an RefCell, but this feature would be a non-unsafe replacement.

[bluss]

@Columbus240 You can implement ptr_eq or compare raw pointers (comparing *const RefCell<T> in your case) directly, don't need unsafe.

[Columbus240]

I noticed that too, I misunderstood the concept of raw pointers in Rust, this is the first time I use them.
ptr_eq would be a nice abstraction instead of manually checking the equality.

[emosenkis]

The ref_eq crate now provides this (implementation taken from an old version that was deleted from the standard library)

[SimonSapin]

rust-lang/rust#35992 implements this.