Remove consecutive duplicate elements in-place in Rust - vector

Question

I have the following python function that removes consecutive duplicated numbers in-place (meaning [0, 0, 1, 1, 1, 2, 2, 3] becomes [0, 1, 2, 3]):
def del_consec_dupl(nums: List[int]):
for (idx, n) in enumerate(nums):
while idx < len(nums) - 1 and n == nums[idx + 1]:
del nums[idx]
it needs to be rewritten in Rust while respecting the constraint that it must work in-place without allocating an extra vector/array. When trying to literally translating this:
fn del_consec_dupl(nums: &mut Vec<i32>) {
for (idx, n) in nums.iter().enumerate() {
while idx < nums.len() - 1 && *n == nums[idx + 1] {
nums.remove(idx);
}
}
}
will produce the following errors:
error[E0502]: cannot borrow `*nums` as immutable because it is also borrowed as mutable
--> src/main.rs:4:21
|
3 | for (idx, n) in nums.iter_mut().enumerate() {
| ---------------------------
| |
| mutable borrow occurs here
| mutable borrow later used here
4 | while idx < nums.len() - 1 && *n == nums[idx + 1] {
| ^^^^ immutable borrow occurs here
error[E0502]: cannot borrow `*nums` as immutable because it is also borrowed as mutable
--> src/main.rs:4:45
|
3 | for (idx, n) in nums.iter_mut().enumerate() {
| ---------------------------
| |
| mutable borrow occurs here
| mutable borrow later used here
4 | while idx < nums.len() - 1 && *n == nums[idx + 1] {
| ^^^^ immutable borrow occurs here
error[E0499]: cannot borrow `*nums` as mutable more than once at a time
--> src/main.rs:5:13
|
3 | for (idx, n) in nums.iter_mut().enumerate() {
| ---------------------------
| |
| first mutable borrow occurs here
| first borrow later used here
4 | while idx < nums.len() - 1 && *n == nums[idx + 1] {
5 | nums.remove(idx);
| ^^^^ second mutable borrow occurs here
error: aborting due to 3 previous errors
it seems no matter what I do, I can only solve 2 of 3. It seems the main issue here is trying to refer to the length of the vector while it is being mutated inside the iteration.
Would I need an unsafe block here? or how would you go about solving it?

Answer 1

I would not use remove which moves all the elements after the given index and is inefficient, but just overwrite elements in the same array, dealing with the double-borrow problem by using indexes:
fn del_consec_dupl(nums: &mut Vec<i32>) {
let mut di = 0; // "destination" increment
for si in 1..nums.len() { // increment on the "source"
if nums[si] != nums[si-1] {
di += 1;
nums[di] = nums[si];
}
}
nums.truncate(di+1); // cut off the tail
}
There's no need to use unsafe here.

Answer 2

Rust vectors provide the built-in dedup() method which does exactly what you are asking for, so the easiest way to write your code is nums.dedup();.
For integers, or more generally Copy types, you can also implement the same functionality using the retain() method:
fn retain_uniq<T: Copy + PartialEq>(nums: &mut Vec<T>) {
let mut previous = None;
nums.retain(|&x| Some(x) != std::mem::replace(&mut previous, Some(x)))
}