rust sharing read-only reference which is mutated in other places - rust

Question

How do split a struct into separate read and write objects? I.e. The struct Foo has a member called bar which I want to have as a read-only reference in some part of the program (the readonly method), and I want to be able to simultaneously mutate bar in another part of the program (the main function).
I have the following scenario:
use futures::stream::StreamExt;
struct Foo {
bar: u8
}
impl Foo {
fn readonly(self: &Self) -> impl futures::stream::Stream<Item = u8> + '_ {
futures::stream::iter(0..10).map(|_x| {
self.bar
})
}
}
#[tokio::main]
async fn main() {
let mut foo = Foo {bar: 123u8};
let mut stream = foo.readonly();
let a = stream.next().await;
println!("a: {:?}", a);
foo.bar = 132;
let b = stream.next().await;
println!("b: {:?}", b);
}
which gives the compile error:
error[E0506]: cannot assign to `foo.bar` because it is borrowed
--> src/main.rs:23:5
|
18 | let mut stream = foo.readonly();
| -------------- borrow of `foo.bar` occurs here
...
23 | foo.bar = 132;
| ^^^^^^^^^^^^^ assignment to borrowed `foo.bar` occurs here
24 |
25 | let b = stream.next().await;
| ------------- borrow later used here
I tried to solve this by wrapping the struct in a Rc<RefCell<_>>:
use std::{cell::RefCell, rc::Rc};
use futures::stream::StreamExt;
struct Foo {
bar: u8
}
impl Foo {
fn readonly<'a>(self: &'a Self) -> impl futures::stream::Stream<Item = u8> + 'a {
futures::stream::iter(0..10).map(|_x| {
self.bar
})
}
}
#[tokio::main]
async fn main() {
let foo = Rc::new(RefCell::new(Foo {bar: 123u8}));
let foo_cloned = foo.clone();
let foo_borrowed = foo_cloned.borrow();
let mut stream = foo_borrowed.readonly();
let a = stream.next().await;
println!("a: {:?}", a);
foo.borrow_mut().bar = 0u8;
let b = stream.next().await;
println!("b: {:?}", b);
}
but this fails at runtime with:
a: Some(123)
thread 'main' panicked at 'already borrowed: BorrowMutError', src/main.rs:28:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
If I instead use unsafe code it works:
#[tokio::main]
async fn main() {
let foo = Rc::new(RefCell::new(Foo {bar: 123u8}));
let foo_cloned = foo.clone();
let foo_borrowed = foo_cloned.borrow();
let mut stream = foo_borrowed.readonly();
let a = stream.next().await;
println!("a: {:?}", a);
unsafe {
(*foo.as_ptr()).bar = 0u8;
}
let b = stream.next().await;
println!("b: {:?}", b);
}
output:
a: Some(123)
b: Some(0)
playground
is there a better, more specialized way to do this?

Answer 1

You almost got it, but you have to wrap only the part you care about in a Cell or RefCell, not the whole struct:
use std::cell::Cell;
use futures::stream::StreamExt;
struct Foo {
bar: Cell<u8>,
}
impl Foo {
fn readonly(self: &Self) -> impl futures::stream::Stream<Item = u8> + '_ {
futures::stream::iter(0..10).map(|_x| {
self.bar.get()
})
}
}
#[tokio::main]
async fn main() {
let mut foo = Foo {bar: Cell::new(123u8)};
let mut stream = foo.readonly();
let a = stream.next().await;
println!("a: {:?}", a);
foo.bar.set(132);
let b = stream.next().await;
println!("b: {:?}", b);
}