This is horrible in my view. All types that implement Deref and/or DerefMut can be called smart pointers, and everything is "thread-safe" in safe Rust.

If I had to call something "Rust's thread-safe smart pointer", it would be the actual references &T/&mut T where T: Send + Sync.

Digression: All the traits involved like the 4 mentioned above point to the C++ centric concept of smart pointer not mapping cleanly to Rust semantics imho. But that's a long lost battle.

Let's see what the official Arc docs say:

A thread-safe reference-counting pointer.

Will you look at that! An actually accurate short description that is already available.

While not widespread, there is already a small myth out there that paints Rust as if it's Swift-like, a ref-counting centric language.

[–] TehPers@beehaw.org 6 points 2 weeks ago* (last edited 2 weeks ago)

This is a very pedantic complaint. Given that you haven't read past the first sentence, I'm not really sure what to discuss here.

"Smart pointer" is commonly used to refer to reference-counted pointers that free automatically.

[–] fruitcantfly@programming.dev 4 points 2 weeks ago* (last edited 2 weeks ago) (1 children)

This is horrible in my view. All types that implement Deref and/or DerefMut can be called smart pointers, and everything is “thread-safe” in safe Rust.

If I had to call something “Rust’s thread-safe smart pointer”, it would be the actual references &T/&mut T where T: Send + Sync.

Not everything is thread-safe in safe rust; while safe rust prevents you from using thread-unsafe constructs in a threaded context, most types are not thread-safe. That's why you have both Rc and Arc, since it is not safe to use non-atomic reference counting in a threaded context, but you don't need the overhead of atomics in a non-threaded context.

Nor are references &T/&mut T where T: Send + Sync considered smart pointers in Rust. Those are just references to something that itself implements the traits required to make that type thread-safe.

[–] BB_C@programming.dev 1 points 2 weeks ago

most types are not thread-safe.

Safe rust is thread-safe in the sense that you can't have runtime thread unsafely. If we are going to ignore the role of compile-time errors, then literally nothing is safe.

Also, what is "most"? Can you source that claim?