Functions that convert between pure-style (A -> A) and mutating (&mut A -> ()) functions.

pure <-> mut

fn mut_to_pure<'f, A, FI>(mut f: FI) -> Box<FnMut(A) -> A+'f>
    where FI: FnMut(&mut A)+'f {
        Box::new(move |mut a| {f(&mut a); a}) 
}
 
fn pure_to_mut<'f, A, FI>(mut f: FI) -> Box<FnMut(&mut A)+'f>
    where FI: FnMut(A) -> A+'f {
        Box::new(move |a: &mut A| {
            unsafe {
                let mut temp: A = std::mem::uninitialized();
                std::mem::swap(a, &mut temp); // a now contains garbage, temp contains value in question
                let mut temp = f(temp);
                std::mem::swap(a, &mut temp);
                std::mem::forget(temp);
            }
        })
}
 
 
fn main() {
    let a = mut_to_pure(|a: &mut i32| *a = *a + 1)(5i32);
    println!("{}", a);
    let mut a = 7i32;
    pure_to_mut(|a: i32| a + 1)(&mut a);
    println!("{}", a);
}

Note that as noted in IRC by someone else, the unsafe code in pure_to_mut might not be safe in the event of a panic.