you are viewing a single comment's thread
view the rest of the comments
[–] -1 points 3 months ago (3 children)

great article!

Is it?

I didn't read past the first sentence:

The Arc type is Rust’s thread-safe smart pointer

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.

  • source
  • parent
  • hideshow 3 child comments
  • [–] 6 points 3 months 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.

  • source
  • parent
  • [–] 4 points 3 months ago* (last edited 3 months ago) (1 child)

    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.

    See also https://doc.rust-lang.org/stable/book/ch15-00-smart-pointers.html and https://doc.rust-lang.org/std/sync/struct.Arc.html#thread-safety

  • source
  • parent
  • hideshow 1 child comment
  • [–] 1 point 3 months 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?

  • source
  • parent