Немного о семантиках перемещения, копирования и заимствования

Существует три основных способа передачи данных в функции: перемещение (move), копирование (copy) и заимствование (borrow, иными словами, передача по ссылке). Поскольку изменяемость (мутабельность) неразрывно связана с передачей данных (например, эта функция может заимствовать мои данные, но только если она обещает смотреть на них и ничего более), в итоге мы получаем шесть различных комбинаций.

Перемещение, копирование, заимствование, мутабельность и иммутабельность

Каждый язык программирования имеет свой уровень поддержки и подход к этим семантикам:

* Технически C поддерживает заимствование через указатели. Однако фактические данные (т.е. адрес, хранящийся в указателе) всегда копируются. Таким образом, можно утверждать, что C поддерживает косвенное заимствование, а не прямое заимствование, как, например, в Rust.

** В Rust по умолчанию используется перемещение, но типы, реализующие трейт Copy, по умолчанию копируются.

Кто знал, что все окажется так запутанно? В C все типы являются примитивными. Когда вы хотите передать “ссылку”, вы передаете адрес ячейки памяти через указатель. Этот указатель в действительности представляет собой просто целочисленное значение, которое копируется так же, как и все остальное. В большинстве языков со сборкой мусора, таких как C# или Java, сложные типы передаются по изменяемой ссылке. Rust же немного выделяется на фоне остальных языков, поддерживая все шесть семантик и по умолчанию используя для сложных типов семантику перемещения, а не заимствования.

Непоследовательность

Интересно то, что из всех этих языков последователен в плане семантики только C. При вызове функции все значения всегда копируются. Вот так просто. Во всех других языках замена одного типа параметра на другой в какой-нибудь прекрасно работающей до этого функции не гарантирует, что она продолжит работать должным образом. Давайте взглянем на пару примеров, приведенных ниже.

C

int example1(int value, char message) { // value копируется // message копируется, память, на которую указывает message, не копируется } char* msg = malloc(100); example1(1, msg); // example1 неявно обязан никуда не передавать msg (заимствование) free(msg);

int example2(int value, char message) { // value копируется // message копируется, память, на которую указывает message, не копируется free(msg); } char* msg = malloc(100); example2(1, msg); // example2 неявно обязан высвобождать msg (перемещение)

int example3(int value, const char message) { // value копируется // message копируется, память, на которую указывает message, не копируется // message является неизменяемым, однако мы можем убрать неизменяемость с помощью приведения типа (каста)... char mut_message = (char )message; } char* msg = malloc(100); example3(1, msg); free(msg);

Плюсы:

1. Идеальная согласованность, так как все всегда копируется.

2. Мутабельность явно указана в сигнатуре функции через ‘const’

Недостатки:

1. Нет семантики перемещения, поэтому компилятор не может проверить наличие тривиальных утечек памяти или двойных высвобождений.

2. Функции, получившие константное значение, могут привести его обратно к неконстантному.

Мои наблюдения:

1. C поддерживает только семантику копирования, но оптимизирующие компиляторы преобразуют в перемещения все, что возможно. В этих случаях оптимизированный код обычно эквивалентен передаче указателя.

C#

int example1(int value, string message) { // value копируется // message заимствуется с возможностью изменения (передается по ссылке) } example1(1, "hello world");

int example2(ref int value, string message) { // value заимствуется с возможностью изменения (передается по ссылке) // message заимствуется с возможностью изменения (передается по ссылке) } example2(ref int_var, "hello world");

Плюсы:

1. Передача примитивов по ссылке явно указана в сигнатуре функции (ref).

Недостатки:

1. Передача примитивов по ссылке также является явной для вызывающей стороны. Изменение сигнатуры функции подразумевает изменения во всех местах вызова.

2. Сложные типы могут передаваться только по ссылке (в C# они даже называются “ссылочными типами”).

3. Нет семантики заимствования без возможности изменения.

4. Нет семантики перемещения.

Мои наблюдения:

1. При наличии сборщика мусора, в таких языках, как C# или Java, вероятно, нет особого смысла для семантики перемещения, поскольку сборщик мусора в конечном итоге позаботится обо всей памяти, выделенной в куче.

Rust

fn example1(value: i32, message: String) -> i32 { // value копируется // message перемещается } example1(1, "hello world".to_string());

fn example2(value: i32, message: SomeTypeThatImplementsCopy) -> i32 { // value копируется // message копируется } example2(1, some_copy_var);

fn example3(value: &i32, message: &mut String) -> i32 { // value заимствуется без возможности изменения // message заимствуется с возможностью изменения } let val = 1; let mut msg = "hello world".to_string(); example3(&val, &mut msg);

Плюсы:

1. Поддержка всех основных семантических случаев перемещения/копирования/заимствования.

2. Заимствование явно указано в сигнатуре функции.

Недостатки:

1. Что будет использоваться по умолчанию — перемещение или копирование, определяется для каждого типа отдельно. Это означает, что сигнатура функции не может сказать вам, что будет использовано для данного параметра.

2. Если перемещение/копирование нежелательно в конкретной ситуации, то есть два способа отключить это поведение по умолчанию в зависимости от того, в каком направлении вам нужно двигаться (перемещение ->копирование или копирование->перемещение).

3. Примитивные типы нельзя перемещать. Это, вероятно, не имеет такого большого значения, но я считаю это непоследовательным.

Мои наблюдения:

1. Rust стремится превзойти C, поддерживая семантику перемещения, но неявное перемещение/копирование вносит некоторый беспорядок. Со стороны реализации функции не имеет значения, что в итоге будет задействовано, потому что данные в любом случае принадлежат функции. Но, с точки зрения вызывающей стороны, вы всегда должны помнить, какие типы реализуют трейт Copy. Это также может привести к неочевидным проблемам:

fn foo<T>(value: T) { // ... }  // это работает let c: char = 'c'; foo(c); // здесь c был скопирован foo(c); // здесь c был скопирован  // а это нет let s: String = "c".to_string(); foo(s); // здесь s была перемещена foo(s); // s больше не находится в этой области видимости; ошибка компиляции

Как человек, которого раздражает такая непоследовательность в языках программирования, я задался вопросом, есть ли лучший способ.

Копирование — это замаскированное перемещение

В чем разница между копированием и перемещением? Если вы немного поразмыслите над этим, вы сразу поймете, что копирование — это просто дублирование данных с последующим перемещением. Единственная разница, с точки зрения вызывающей стороны, заключается в том, перемещаете ли вы исходные данные или их копию. С точки зрения функции разницы нет; данные получены в любом случае. Возникает вопрос, почему вообще копирование связано с сигнатурами функций? Не лучше ли иметь какую-нибудь явную поддержку копирования на уровне языка, которая никак не связана с функциями или их сигнатурами? Rust, например, стоило очень многих хлопот сохранить явную аллокацию данных, но, в конечном итоге, главный индикатор, будет ли что-либо копироваться или перемещаться, сводится к тому, как это называется. Почему бы не сделать что-то простое и понятное как, например, это?

// отправляет сложный тип в другой поток или добавляет в очередь на выполнение и т.д. fn send(item: move ComplexType) { ... }  let original: ComplextType = ComplexType::new(); // создаем явную копию элемента  let clone = copy original; // отправляем копию оригинала  send (clone); // - или -  send(copy original); // отправляем исходный элемент  send(original);

Так копирование является явным и не связано с вызовом функции.

Чего же я на самом деле хочу от языка программирования?

Мои самые большие претензии к языкам программирования на данный момент таковы:

1. Отсутствие последовательности.

2. Копирование связано с вызовом функций.

Очевидным решением здесь является явная семантика перемещения/заимствования с последовательными умолчательным и явным операторами копирования.

1. Семантически, поведением по умолчанию всегда является иммутабельное заимствование, независимо от типа

2. Явно аннотируйте параметры функции для всех остальных случаев. Аннотации иммутабельности и заимствования могут быть необязательными.

3. Явные аннотации не требуются в местах вызова.

4. Мутабельность неявно преобразуется в иммутабельность. Иммутабельность никогда не может быть преобразована в мутабельность.

5. Копирование всегда явное.

Копирование теперь выходит за рамки этой таблицы для нашего гипотетического языка, потому что теперь это отдельная языковая фича.

Заимствование

fn example1(value: i32, message: String) { // то же, что и для fn example1(value: ref i32, message: ref String) { // value и message заимствуются без возможности изменения } let mut val = 1; // val является мутабельной в этой области видимости let msg = "hello world"; // msg иммутабельное в этой области видимости example1(val, msg); // оба могут быть заимствованы без возможности изменения example1(val, msg); // многократно

fn example2(value: mut i32, message: mut String) { // то же, что и для fn example2(value: mut ref i32, message: mut ref String) { // value и message заимствуются с возможностью изменения value += 2; }  let val = 1; let msg = "hello world"; example2(val, msg); // ошибка компиляции, и val, и msg иммутабельные  let mut val = 1; let mut msg = "hello world"; example2(val, msg); example2(val, msg); // value равно 5

Перемещение

fn example3(value: move i32, message: move String) { // value и message перемещаются без возможности изменения } let mut val = 1; let msg = "hello world"; example3(val, msg); // val становится иммутабельной при перемещении example3(val, msg); // ошибка компиляции, val и msg перемещены в example3

fn example4(value: mut move i32, message: mut move String) { // value и message перемещаются с возможностью изменения } let mut val = 1; let msg = "hello world"; example4(val, msg); // ошибка компиляции, msg иммутабельное example4(val, msg); // ошибка компиляции, val и msg перемещены в example4

Копирование

fn example5(value: move i32, message: move String) { // value и message перемещаются без возможности изменения } let val = 1; let msg = "hello world"; example5(copy val, copy msg); example5(copy val, copy msg);

fn example6(value: mut move i32, message: mut move String) { // value и message копируются с возможностью изменения value += 2; } let mut val = 1; let msg = "hello world"; // мутабельность определяется псевдонимом (в данном случае message) // значит, тут все в порядке, хоть msg и иммутабельно example6(copy val, copy msg); example6(copy val, copy msg); // val по-прежнему 1

---

Приглашаем всех желающих на открытое занятие «Сборка и запуск приложений. Туллинг Rust», которое состоится уже завтра в рамках онлайн-курса «Rust Developer. Basic». На занятии мы разберёмся, из каких этапов состоит сборка приложения, и как операционная система его запускает. Познакомимся с инструментами Rust для сборки и работы с кодом. Записаться на урок можно по ссылке.