replace parameters order matter

[Stargateur]

replace can be annoying to use as one liner because of the borrow checker, a good solution is to swap arguments order:

fn main() {
    let mut i = 0;
    
    assert_eq!(0, replace(i + 1, &mut i));
    assert_eq!(1, std::mem::replace(&mut i, i + 1));
    assert_eq!(2, i);
}

fn replace<T>(src: T, dest: &mut T) -> T {
  core::mem::replace(dest, src)
}

rror[E0503]: cannot use `i` because it was mutably borrowed
 --> src/main.rs:5:45
  |
5 |     assert_eq!(1, std::mem::replace(&mut i, i + 1));
  |                   ----------------- ------  ^ use of borrowed `i`
  |                   |                 |
  |                   |                 borrow of `i` occurs here
  |                   borrow later used by call

Unfortunately, in my knowledge even Rust edition can't allow this breaking change, I see potential solution:

1. add a new function in mem module (what name ? replace2() ?)
2. breaking change somehow
3. do nothing and live with it

[Dylan-DPC]

Closing this to clean up the issue tracker. if you need to use it you can use the workaround that you posted as an example