Is it considered a bad practice to implement Deref for newtypes?

by

the rules regarding Deref and DerefMut were designed specifically to accommodate smart pointers. Because of this, Deref should only be implemented for smart pointers to avoid confusion.

— std::ops::Deref

I think it’s a bad practice.

since I can use my newtype as if it were the underlying type in some situations

That’s the problem — it can be implicitly used as the underlying type whenever a reference is. If you implement DerefMut, then it also applies when a mutable reference is needed.

You don’t have any control over what is and what is not available from the underlying type; everything is. In your example, do you want to allow people to call as_ptr? What about sort? I sure hope you do, because they can!

About all you can do is attempt to overwrite methods, but they still have to exist:

impl MyArray {
    fn as_ptr(&self) -> *const i32 {
        panic!("No, you don't!")
    }
}

Even then, they can still be called explicitly (<[i32]>::as_ptr(&*my_array);).

I consider it bad practice for the same reason I believe that using inheritance for code reuse is bad practice. In your example, you are essentially inheriting from an array. I’d never write something like the following Ruby:

class MyArray < Array
  # ...
end

This comes back to the is-a and has-a concepts from object-oriented modeling. Is MyArray an array? Should it be able to be used anywhere an array can? Does it have preconditions that the object should uphold that a consumer shouldn’t be able to break?

but I am tired of writing my_type.0.call_to_whatever(...)

Like in other languages, I believe the correct solution is composition over inheritance. If you need to forward a call, create a method on the newtype:

impl MyArray {
    fn call_to_whatever(&self) { self.0.call_to_whatever() } 
}

The main thing that makes this painful in Rust is the lack of delegation. A hypothetical delegation syntax could be something like

impl MyArray {
    delegate call_to_whatever -> self.0; 
}

While waiting for first-class delegation, we can use crates like delegate or ambassador to help fill in some of the gaps.

So when should you use Deref / DerefMut? I’d advocate that the only time it makes sense is when you are implementing a smart pointer.

Speaking practically, I do use Deref / DerefMut for newtypes that are not exposed publicly on projects where I am the sole or majority contributor. This is because I trust myself and have good knowledge of what I mean. If delegation syntax existed, I wouldn’t.

More Related Contents:

  1. What is the relation between auto-dereferencing and deref coercion?
  2. Why does a mutable borrow of a closure through DerefMut not work?
  3. Why do try!() and ? not compile when used in a function that doesn’t return Option or Result?
  4. Why do I need to import a trait to use the methods it defines for a type?
  5. Why does linking lifetimes matter only with mutable references?
  6. Why is adding a lifetime to a trait with the plus operator (Iterator + ‘a) needed?
  7. Should trait bounds be duplicated in struct and impl?
  8. Cannot infer an appropriate lifetime for autoref due to conflicting requirements
  9. How do I borrow a reference to what is inside an Option?
  10. What is lifetime elision in very simple terms?
  11. Why does this read input before printing?
  12. How to create a String directly?
  13. How to create an in-memory object that can be used as a Reader, Writer, or Seek in Rust?
  14. What’s the Rust idiom to define a field pointing to a C opaque pointer?
  15. Can’t borrow mutably within two different closures in the same scope
  16. What is the syntax to match on a reference to an enum?
  17. How can I implement Rust’s Copy trait?
  18. How to use a struct’s member as its own key when inserting the struct into a map without duplicating it?
  19. Why can’t I return an &str value generated from a String?
  20. Is there another option to share an Arc in multiple closures besides cloning it before each closure?
  21. How to implement a custom ‘fmt::Debug’ trait?
  22. How do I pass a closure through raw pointers as an argument to a C function?
  23. What is the prelude?
  24. How do I use a crate from another crate without explicitly defining a new dependency in my project?
  25. Why is Rust’s assert_eq! implemented using a match?
  26. Is there a list of all cfg features?
  27. How to repeat a static string at compile time
  28. Is there a good way to convert a Vec to an array?
  29. How to concatenate static strings in Rust
  30. How can I conditionally provide a default reference without performing unnecessary computation when it isn’t used?

Leave a Comment