It is called Remainder (I think) because it doesn’t have to be the modulo operation, but you can implement it for any type you want, e.g. (taken from the Rem example)

```
use std::ops::Rem;
#[derive(PartialEq, Debug)]
struct SplitSlice<'a, T: 'a> {
slice: &'a [T],
}
impl<'a, T> Rem<usize> for SplitSlice<'a, T> {
type Output = SplitSlice<'a, T>;
fn rem(self, modulus: usize) -> Self {
let len = self.slice.len();
let rem = len % modulus;
let start = len - rem;
SplitSlice {slice: &self.slice[start..]}
}
}
// If we were to divide &[0, 1, 2, 3, 4, 5, 6, 7] into slices of size 3,
// the remainder would be &[6, 7].
assert_eq!(SplitSlice { slice: &[0, 1, 2, 3, 4, 5, 6, 7] } % 3,
SplitSlice { slice: &[6, 7] });
```

In this context modulo would not make much sense. Also if you think about it integer wise they give you the remaining value.

Maybe someone else can explain why they decided to call it Remainder?