rust - react - porque el lenguaje es inmutable

No se puede tomar prestado como inmutable porque también se toma prestado como mutable en los argumentos de función

Question

¿Qué está pasando aquí ( playground )?

struct Number {
    num: i32
}

impl Number {
    fn set(&mut self, new_num: i32) {
        self.num = new_num;
    }
    fn get(&self) -> i32 {
        self.num
    }
}

fn main() {
    let mut n = Number{ num: 0 };
    n.set(n.get() + 1);
}

Da este error:

error[E0502]: cannot borrow `n` as immutable because it is also borrowed as mutable
  --> <anon>:17:11
   |
17 |     n.set(n.get() + 1);
   |     -     ^          - mutable borrow ends here
   |     |     |
   |     |     immutable borrow occurs here
   |     mutable borrow occurs here

Sin embargo, si simplemente cambia el código a esto, funciona:

fn main() {
    let mut n = Number{ num: 0 };
    let tmp = n.get() + 1;
    n.set(tmp);
}

Para mí, esos se ven exactamente equivalentes, es decir, esperaría que el primero se transformara en el segundo durante la compilación. ¿Rust no evalúa todos los parámetros de la función antes de evaluar la llamada a la función de nivel superior?

Answer 1

Esta línea:

n.set(n.get() + 1);

se desuga en

Number::set(&mut n, n.get() + 1);

El mensaje de error podría ser un poco más claro ahora:

error[E0502]: cannot borrow `n` as immutable because it is also borrowed as mutable
  --> <anon>:18:25
   |
18 |     Number::set(&mut n, n.get() + 1);
   |                      -  ^          - mutable borrow ends here
   |                      |  |
   |                      |  immutable borrow occurs here
   |                      mutable borrow occurs here

A medida que Rust evalúa los argumentos de izquierda a derecha, ese código es equivalente a esto:

let arg1 = &mut n;
let arg2 = n.get() + 1;
Number::set(arg1, arg2);

Ahora debería ser obvio lo que está mal. Intercambiando esas dos primeras líneas, arregla esto, pero Rust no hace ese tipo de análisis de flujo de control.

Esto se creó por primera vez como error # 6268 , ahora está integrado en RFC 2094 , non-lexical-lifetimes . Si usa Rust 2018, NLL se habilita automáticamente y su código ahora se compilará sin errores .