How to implement Add trait without consuming the value [duplicate]

Question

When implementing the Add trait (and a few others, like Mul, Sub, etc.) for a simple struct one has to fully consume the struct value, thus its later use is not possible.

At the same time, built in primitives (u8, usize, etc.) implement Add while allowing using it after add was called.

How can I implement Add for my structs to be able to use it after calling add?

use std::ops::Add;

struct I(usize);
impl Add for I {
    type Output = Self;
    fn add(self, rhs: Self) -> Self {
        I(self.0 + rhs.0)
    }
}

fn main() {
    let a = 123;
    let b = a + a; // no error

    let a1 = I(123);
    let b1 = a1 + a1;

    println!("b={}", b);
}

error[E0382]: use of moved value: `a1`
  --> src/main.rs:16:19
   |
15 |     let a1 = I(123);
   |         -- move occurs because `a1` has type `I`, which does not implement the `Copy` trait
16 |     let b1 = a1 + a1;
   |              --   ^^ value used here after move
   |              |
   |              value moved here

@jhpratt can you elaborate on your answer pls, and maybe provide an example implementation? — dark_ruby
– dark_ruby, Commented Jul 31, 2019 at 15:22
Ryan's answer should suffice, but I'll give you an example of what I mentioned as well. — jhpratt
– jhpratt, Commented Jul 31, 2019 at 15:25

Gray · Accepted Answer · 2019-07-31 15:23:44Z

3

You should be able to add #[derive(Copy, Clone)] to the struct, and then instead of consuming the value, it'll consume a copy.

answered Jul 31, 2019 at 15:23

Gray

2,3531 gold badge19 silver badges24 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Shepmaster · Accepted Answer · 2019-07-31 16:07:23Z

1

You can impl Deref and dereference the value. This will work for types that are simple wrappers around an Add type.

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

struct I(usize);
impl Add for I {
    type Output = Self;
    fn add(self, rhs: Self) -> Self {
        I(self.0 + rhs.0)
    }
}

impl Deref for I {
    type Target = usize;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

fn main() {
    let a = 123;
    let b = a + a; // no error

    let a1 = I(123);

    // Note the dereferences.
    let b1 = *a1 + *a1;

    println!("b={}", b);
}

NB: Ryan's answer should suffice in this case, as usize is a clone type.

edited Jul 31, 2019 at 16:07

Shepmaster

439k115 gold badges1.3k silver badges1.5k bronze badges

answered Jul 31, 2019 at 15:29

jhpratt

7,15016 gold badges43 silver badges53 bronze badges

3 Comments

Stargateur Over a year ago

I think it's quite odd to do that like that you just write a1.0 + a1.0 that doesn't really solve the problem if your type is not Copy

jhpratt Over a year ago

@Stargateur Things aren't always in the same module.

Shepmaster Over a year ago

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

Collectives™ on Stack Overflow

How to implement Add trait without consuming the value [duplicate]

2 Answers 2

Comments

3 Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

3 Comments

Linked

Related