How to implement idiomatic operator overloading for values and references in Rust?

by

The great thing about Rust is that it’s open source. This means you can see how the authors of the language have solved a problem. The closest analogue is primitive integer types:

macro_rules! add_impl {
    ($($t:ty)*) => ($(
        #[stable(feature = "rust1", since = "1.0.0")]
        impl Add for $t {
            type Output = $t;

            #[inline]
            fn add(self, other: $t) -> $t { self + other }
        }

        forward_ref_binop! { impl Add, add for $t, $t }
    )*)
}

forward_ref_binop is defined as:

macro_rules! forward_ref_binop {
    (impl $imp:ident, $method:ident for $t:ty, $u:ty) => {
        #[stable(feature = "rust1", since = "1.0.0")]
        impl<'a> $imp<$u> for &'a $t {
            type Output = <$t as $imp<$u>>::Output;

            #[inline]
            fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
                $imp::$method(*self, other)
            }
        }

        #[stable(feature = "rust1", since = "1.0.0")]
        impl<'a> $imp<&'a $u> for $t {
            type Output = <$t as $imp<$u>>::Output;

            #[inline]
            fn $method(self, other: &'a $u) -> <$t as $imp<$u>>::Output {
                $imp::$method(self, *other)
            }
        }

        #[stable(feature = "rust1", since = "1.0.0")]
        impl<'a, 'b> $imp<&'a $u> for &'b $t {
            type Output = <$t as $imp<$u>>::Output;

            #[inline]
            fn $method(self, other: &'a $u) -> <$t as $imp<$u>>::Output {
                $imp::$method(*self, *other)
            }
        }
    }
}

It’s certainly valid to write wrapper implementations of the traits for references that simply dereference and call the value-oriented version.

More Related Contents:

  1. How can an operator be overloaded for different RHS types and return values?
  2. What is the correct way to return an Iterator (or any other trait)?
  3. How should I write ISO C++ Standard conformant custom new and delete operators?
  4. How to properly overload the
  5. Why does Future::select choose the future with a longer sleep period first?
  6. Overload resolution failure when streaming object via implicit conversion to string
  7. Initialize a large, fixed-size array with non-Copy types
  8. How can I avoid a ripple effect from changing a concrete struct to generic?
  9. How to use one module from another module in a Rust cargo project?
  10. Sending trait objects between threads in Rust
  11. Why would I implement methods on a trait instead of as part of the trait?
  12. Why istream object can be used as a bool expression?
  13. How can I update a value in a mutable HashMap?
  14. “Expected fn item, found a different fn item” when working with function pointers
  15. How do you unwrap a Result on Ok or return from the function on Err?
  16. Iterating over a slice’s values instead of references in Rust?
  17. How do I read the entire body of a Tokio-based Hyper request?
  18. What is the difference between ‘&self’ and ‘&’a self’?
  19. How can I downcast from Box to a trait object type?
  20. Using the less than comparison operator for strings
  21. How does Rust pattern matching determine if the bound variable will be a reference or a value?
  22. How do I overload the [] operator in C# [duplicate]
  23. Error installing a crate via cargo: specified package has no binaries
  24. Can I use the “null pointer optimization” for my own non-pointer types?
  25. What is a crate attribute and where do I add it?
  26. Converting a hexadecimal string to a decimal integer
  27. How to compose functions in Rust?
  28. How to model complex recursive data structures (graphs)?
  29. How can I define an async method in a trait?
  30. How do I specify the linker path in Rust?

Leave a Comment