Почему переменная ссылка не перемещается здесь?

Question

У меня создалось впечатление, что изменяемые ссылки (т. Е. &mut T) всегда перемещаются. Это имеет прекрасный смысл, поскольку они допускают эксклюзивный доступ к изменяемым данным. В следующем фрагменте кода я назначаю измененную ссылку на другую изменяемую ссылку, и оригинал перемещается. В результате я не могу использовать оригинал больше:

let mut value = 900; 
let r_original = &mut value; 
let r_new = r_original; 
*r_original; // error: use of moved value *r_original 

Если у меня есть функция, как это:

fn make_move(_: &mut i32) { 
} 

и изменить свой оригинальный пример, чтобы выглядеть следующим образом:

let mut value = 900; 
let r_original = &mut value; 
make_move(r_original); 
*r_original; // no complain 

Я ожидал бы, что изменяемая ссылка r_original перемещается, когда я вызываю ее с помощью функции make_move. Однако этого не происходит. Я все еще могу использовать ссылку после вызова.

Если я использую функцию универсального make_move_gen:

fn make_move_gen<T>(_: T) { 
} 

и назвать его так:

let mut value = 900; 
let r_original = &mut value; 
make_move_gen(r_original); 
*r_original; // error: use of moved value *r_original 

Ссылка перемещается снова и, следовательно, программа ведет себя, как я бы ожидать. Почему ссылка не перемещается при вызове функции make_move?

Code example

Answer 1

Возможно, для этого есть веская причина.

&mut T не Фактически a тип: все заимствования параметризуются некоторым (потенциально невыразимым) временем жизни.

Когда один пишет

fn move_try(val: &mut()) { 
    { let new = val; } 
    *val 
} 

fn main() { 
    move_try(&mut()); 
} 

механизм логического вывода типа typeof new == typeof val делает вывод, поэтому они имеют оригинальный срок службы. Это означает, что заем от new не заканчивается до тех пор, пока займ от val не сделает.

Это означает, что эквивалентно

fn move_try<'a>(val: &'a mut()) { 
    { let new: &'a mut _ = val; } 
    *val 
} 

fn main() { 
    move_try(&mut()); 
} 

Однако, когда вы пишете

fn move_try(val: &mut()) { 
    { let new: &mut _ = val; } 
    *val 
} 

fn main() { 
    move_try(&mut()); 
} 

литая бывает - такой же вещи, что позволяет откинуть указатель переменчивость. Это означает, что время жизни является некоторым (казалось бы, неопределенным) 'b < 'a. Это включает в себя бросок и, следовательно, переборку, и поэтому перебор может выйти из сферы действия.

Правило всегда-reborrow, вероятно, будет приятнее, но явное объявление не является слишком проблематичным.

Answer 2

я спросил что-то вдоль этих линий here.

Кажется, что в некоторых (много?) Случаях вместо перемещения происходит повторное заимствование. Безопасность памяти не нарушена, только «перемещенное» значение все еще находится вокруг. Я тоже не мог найти никаких документов по этому поведению.

@ Levans открыла проблему github here, хотя я не совсем уверен, что это просто проблема с док-станцией: надежное перемещение из ссылки & кажется центральным для подхода Rust к владению.