Разработайте трейт в Rust с изменяемым геттером и неизменяемым геттером, который реализует неизменный геттер по умолчанию

Нет, это не звук.

Пользователь может изменить self в своей реализации inside_mut, что также изменит структуру в inside_ref.

Так:

pub trait MyTrait<T> {
    fn inside_mut(&mut self) -> &mut T;

    fn inside_ref(&self) -> &T {
        let ptr = self as *const Self as *mut Self;
        &*unsafe { (&mut *ptr).inside_mut() }
    }
}

#[derive(Debug)]
struct MyStruct {
    value: i32,
}

impl MyTrait<i32> for MyStruct {
    fn inside_mut(&mut self) -> &mut i32 {
        self.value += 1;
        &mut self.value
    }
}

fn main() {
    // Important: this is not `mut`!!!
    let x = MyStruct { value: 42 };

    println!("{:?}", x);
    x.inside_ref();
    println!("{:?}", x);
}

MyStruct { value: 42 }
MyStruct { value: 43 }

Это означает, что эта реализация несостоятельна:

Поведение считается неопределенным

• Изменение неизменяемых данных. Все данные внутри элемента const неизменяемы. Более того, все данные, полученные через общую ссылку или данные, принадлежащие неизменяемой привязке, являются неизменяемыми, если только эти данные не содержатся в UnsafeCell<U>.

Посмотрев на ответ Finomnis, я пришел к этому решению (площадка), для которого miri не выдает предупреждение UB:

use core::cell::UnsafeCell;
pub trait MyTrait<T> {
    fn inside_mut(&mut self) -> &mut T {
        let ptr = self.implement_ref().get();
        unsafe { &mut *ptr }
    }

    fn inside_ref(&self) -> &T {
        let ptr = self.implement_ref().get();
        unsafe { & *ptr }
    }

    fn implement_ref(&self) -> &UnsafeCell<T>;
}

pub struct Data(UnsafeCell<String>);

impl Data {
    pub fn new(s:String) -> Self {
        Data(UnsafeCell::new(s))
    }    
}

impl MyTrait<String> for Data {
    fn implement_ref(&self) -> &UnsafeCell<String> { &self.0 }
}

fn main() {
    let mut data = Data::new(format!("Foo"));
    let x: &String = data.inside_ref();
    let y: &String = data.inside_ref();
    println!("x -> {x}");
    println!("y -> {y}");
    *data.inside_mut() = format!("Bar");
    println!("data.0 -> {}", data.inside_ref());
}

Тем не менее, у меня все еще есть вопрос. Мири выдает UB-алерт для следующего кода (площадка):

pub trait MyTrait<T> {
    fn inside_ref(&self) -> &T;
    
    fn inside_mut(&mut self) -> &mut T  {
        let ptr = self.inside_ref() as *const T as *mut T;
        unsafe { &mut *ptr }
    }
}

pub struct Data(String);
impl MyTrait<String> for Data {
    fn inside_ref(&self) -> &String { &self.0 }
}

fn main() {
    let mut data = Data(format!("Foo"));
    let x: &String = data.inside_ref();
    let y: &String = data.inside_ref();
    println!("x -> {x}");
    println!("y -> {y}");
    *data.inside_mut() = format!("Bar");
    println!("data.0 -> {}", data.0);
}

Но хороший контрпример, представленный Finomnis, в этом случае не работает. Может ли кто-нибудь привести иллюстрацию несостоятельности последнего случая?

Обновлено: вдохновлено контрпримером cafce25 (детская площадка):

static IMMUTABLE_STATIC_STR: &'static str = "IMMUTABLE FOO";

pub trait MyTrait<T> {
    fn inside_ref(&self) -> &T;
    
    fn inside_mut(&mut self) -> &mut T  {
        let ptr = self.inside_ref() as *const T as *mut T;
        unsafe { &mut *ptr }
    }
}

pub struct Data;
impl MyTrait<&'static str> for Data {
    fn inside_ref(&self) -> &&'static str { &IMMUTABLE_STATIC_STR }
}

fn main() {
    let mut data = Data;
    let x: &&'static str = data.inside_ref();
    let y: &&'static str = data.inside_ref();
    println!("x -> {x}");
    println!("y -> {y}");
    *data.inside_mut() = "Bar";
    println!("data.inside_ref() -> {}", data.inside_ref());
}

Результат:

Standard Error

   Compiling playground v0.0.1 (/playground)
    Finished release [optimized] target(s) in 1.61s
     Running `target/release/playground`

Standard Output

x -> IMMUTABLE FOO
y -> IMMUTABLE FOO
data.inside_ref() -> IMMUTABLE FOO