Обобщение над изменчивостью указателя [duplicate]

(ссылки на игровые площадки к решениям с использованием параметров типа и связанных типов )

В этом случае &T и &mut T являются двумя разными типы. Код, который является общим для разных типов (как во время компиляции, так и во время выполнения), идиоматически написан в Rust, используя черты. Например, учитывая:

struct Foo { value: i32 }
struct Bar { foo: Foo }

, предположим, что мы хотим предоставить Bar общий аксессор для своего члена данных Foo. Аксессор должен работать как с &Bar, так и с &mut Bar, соответствующим образом возвращающим &Foo или &mut Foo. Таким образом, мы пишем черту FooGetter

trait FooGetter {
    type Output;
    fn get(self) -> Self::Output;
}

, задача которой должна быть общей для конкретного типа Bar. Его тип Output будет зависеть от Bar, так как мы хотим get иногда возвращать &Foo, а иногда &mut Foo. Обратите также внимание на то, что он потребляет self типа Self. Поскольку мы хотим, чтобы get был общим для &Bar и &mut Bar, нам нужно реализовать FooGetter для обоих, так что Self имеет соответствующие типы:

// FooGetter::Self == &Bar
impl<'a> FooGetter for &'a Bar {
    type Output = &'a Foo;
    fn get(self) -> Self::Output { & self.foo }
}

// FooGetter::Self == &mut Bar
impl<'a> FooGetter for &'a mut Bar {
    type Output = &'a mut Foo;
    fn get(mut self) -> Self::Output { &mut self.foo }
}

Теперь мы можем легко используйте .get() в общем коде, чтобы получить & или &mut ссылки на Foo из &Bar или &mut Bar (просто требуя T: FooGetter). Например:

// exemplary generic function:
fn foo<T: FooGetter>(t: T) -> <T as FooGetter>::Output {
    t.get() 
}

fn main() {
    let x = Bar { foo: Foo {value: 2} };
    let mut y = Bar { foo: Foo {value: 2} };

    foo(&mut y).value = 3;
    println!("{} {}\n", foo(&x).value, foo(&mut y).value);
}

Обратите внимание, что вы также можете реализовать FooGetter для Bar, так что get является общим для &T, &mut T и T (по перемещая его). Это на самом деле способ, которым метод .iter() реализован в стандартной библиотеке и почему он всегда делает «правильную вещь» независимо от ссылочного аргумента, на который он ссылается.

В настоящее время Rust не поддерживает абстрагирование над изменчивостью.

Есть некоторые способы, которыми это может быть достигнуто, хотя они не идеальны:

• Используйте макрос для развернуть дублирующий код, объявить макрос и поделиться между обеими функциями - нужно сконструировать, чтобы он работал для изменяемого и неизменяемого, конечно.
• Напишите неизменяемую версию функции (чтобы гарантировать, что ничего не изменилось) затем напишите функцию-обертку для изменяемой версии, которая выполняет unsafe приведение результата, чтобы сделать его изменчивым.

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

На данный момент лучший вариант, насколько я могу видеть (где код для копирования не подходит), заключается в том, чтобы написать неизменяемую версию функции, а затем обернуть ее с помощью mut версии функции, где бот h входы и выходы изменяемы.

Для этого требуется выход unsafe на выходе функции, поэтому он не идеален.

Примечание: важно иметь неизменяемая функция содержит тело кода, так как обратное позволит случайным образом изменить то, что может быть неизменным.