Proposal: Implement assignment operator overloads

[rust-highfive]

Issue by bjz
Sunday Apr 21, 2013 at 22:16 GMT

For earlier discussion, see rust-lang/rust#5992

This issue was labelled with: A-libs, A-traits, I-enhancement, P-low in the Rust repository

---

This would be very useful for core::num (see #4819), and also mathematics libraries.

// overloads `+=`
#[lang="add_assign"]
trait AddAssign<RHS> {
    fn add_assign(&mut self, &other: RHS);
}

// overloads `-=`
#[lang="sub_assign"]
trait SubAssign<RHS> {
    fn sub_assign(&mut self, &other: RHS);
}

// overloads `*=`
#[lang="mul_assign"]
trait MulAssign<RHS> {
    fn mul_assign(&mut self, &other: RHS);
}

// overloads `/=`
#[lang="quot_assign"]
trait QuotAssign<RHS> {
    fn quot_assign(&mut self, &other: RHS);
}

// overloads `%=`
#[lang="rem_assign"]
trait RemAssign<RHS> {
    fn rem_assign(&mut self, &other: RHS);
}

It would also be useful to be able to assign to values accessed via the index operator. This would return a mutable reference to the element. =, +=, -=, *=, /=, and %= would then be based off the overloads defined for that element type.

#[lang="index_assign"]
trait IndexAssign<Index,Element> {
    fn mut_index<'a>(&'a mut self, index: Index) -> &'a mut Element;
}

Edit: Removed Assign trait for = operator.

[kkimdev]

Q: Why did you remove Assign trait for = operator from the RFC?

[eddyb]

Overloading = would violate Rust's doctrine of "everything moves without side effects".

[mtahmed]

(noob) Q: Does rust provide any way of doing something like this right now?:

let my_big_num: BigNum = 42;

Basically, to be able to assign "constants" to objects and have it work?
If not, would Assign trait have been the answer?
If yes, could you please explain a bit more why the Assign trait is bad?

[Kimundi]

Assign would be about modifying an existing instance of the type, not about creating a fresh one.

And I think for that, you'd rather want to push for making number literals generic, so that that turns into something like let my_big_num: BigNum = literal_from_integer(42);.

[japaric]

Implementation

RFC

[nagisa]

Should default trait implementations like this be provided?

impl<R, T> AddAssign<R> for T 
where T: Add<R> {
    fn add_assign(&mut self, &rhs: R) { *self = self + rhs; }
}

👍 for this either way.

[alexcrichton]

This is done!