Automatically implement traits of enclosed type for Rust newtypes (tuple structs with one field)

by

is there a way to do it without extracting their “inner” values every time with pattern matching, and without implementing the Add, Sub, … traits and overloading operators?

No, the only way is to implement the traits manually. Rust doesn’t have an equivalent to the Haskell’s GHC extension GeneralizedNewtypeDeriving which allows deriving on wrapper types to automatically implement any type class/trait that the wrapped type implements (and with the current set-up of Rust’s #[derive] as a simple AST transformation, implementing it like Haskell is essentially impossible.)

To abbreviate the process, you could use a macro:

use std::ops::{Add, Sub};

macro_rules! obvious_impl {
    (impl $trait_: ident for $type_: ident { fn $method: ident }) => {
        impl $trait_<$type_> for $type_ {
            type Output = $type_;

            fn $method(self, $type_(b): $type_) -> $type_ {
                let $type_(a) = self;
                $type_(a.$method(&b))
            }
        }
    }
}

#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Debug)]
pub struct Centimeters(i32);

obvious_impl! { impl Add for Centimeters { fn add } }
obvious_impl! { impl Sub for Centimeters { fn sub } }

#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Debug)]
pub struct Inches(i32);

obvious_impl! { impl Add for Inches { fn add } }
obvious_impl! { impl Sub for Inches { fn sub } }

fn main() {
    let a = Centimeters(100);
    let b = Centimeters(200);
    let c = Inches(10);
    let d = Inches(20);
    println!("{:?} {:?}", a + b, c + d); // Centimeters(300) Inches(30)
    // error:
    // a + c;
}

playpen

I emulated the normal impl syntax in the macro to make it obvious what is happening just by looking at the macro invocation (i.e. reducing the need to look at the macro definition), and also to maintain Rust’s natural searchability: if you’re looking for traits on Centimeters just grep for for Centimeters and you’ll find these macro invocations along with the normal impls.

If you are accessing the contents of the Centimeters type a lot, you could consider using a proper struct with a field to define the wrapper:

struct Centimeters { amt: i32 }

This allows you to write self.amt instead of having to do the pattern matching. You can also define a function like fn cm(x: i32) -> Centimeters { Centimeters { amt: x } }, called like cm(100), to avoid the verbosity of constructing a full struct.

You can also access the inner values of a tuple struct using the .0, .1 syntax.

More Related Contents:

  1. How to clone a struct storing a boxed trait object?
  2. What is the difference between ‘&self’ and ‘&’a self’?
  3. What lifetimes do I use to create Rust structs that reference each other cyclically?
  4. Traits and Rust
  5. How do I implement a trait I don’t own for a type I don’t own?
  6. How do I use integer number literals when using generic types?
  7. What makes something a “trait object”?
  8. How do I implement the Add trait for a reference to a struct?
  9. Is it possible to access struct fields from within a trait?
  10. Is it possible to use `impl Trait` as a function’s return type in a trait definition?
  11. I implemented a trait for another trait but cannot call methods from both traits
  12. How to set and get fields in struct’s method
  13. Can embedded struct method have knowledge of parent/child?
  14. How do I use floating point number literals when using generic types?
  15. Trait implementation for both a trait object and for direct implementors of the trait
  16. How can I implement Rust’s Copy trait?
  17. When should I not implement a trait for references to implementors of that trait?
  18. Is it possible for one struct to extend an existing struct, keeping all the fields?
  19. Golang : Is conversion between different struct types possible?
  20. Understanding Traits and Object Safety
  21. Why can’t I add a blanket impl on a trait with a type parameter?
  22. How can I store an async function in a struct and call it from a struct instance?
  23. How do I pass a closure through raw pointers as an argument to a C function?
  24. Can’t implement a trait I don’t own for all types that implement a trait I do own
  25. Can traits be used on enum types?
  26. Is it possible to extend a default method implementation of a trait in a struct?
  27. How to avoid code duplication of different structs with semantically equal fields/properties?
  28. Implement fmt::Display for Vec
  29. Cannot use moved BufReader after for loop with bufreader.lines()
  30. Do I have to implement a trait twice when implementing it for both reference and non-reference types?

Leave a Comment