How to get around mutable and immutable references? - rust

Question

I'm creating a library that tries to be a Cache struct that wraps some structure that would be the component that retrieves "fresh data" for example through some HTTP requests; and also a backend field that is the actual cache backend for the data retrieved through the wrapped component.
I'm facing some problems when trying to "refresh" the data in the cache after retrieving some new data.
use std::collections::HashMap;
pub trait Cacheable<K, V>
where K: std::cmp::Eq + std::hash::Hash
{
fn get(&self, k: &K) -> Option<&V>;
fn set(&mut self, k: K, v: V);
fn del(&mut self, k: &K);
}
pub struct Cache<'a, K, V>
where K: std::cmp::Eq + std::hash::Hash
{
wrapped: &'a dyn Cacheable<K, V>,
backend: Box<dyn Cacheable<K, V>>,
}
impl<'a, K, V> Cache<'a, K, V>
where K: std::cmp::Eq + std::hash::Hash + 'static,
V: 'static,
{
fn New(wrapped: &'a dyn Cacheable<K, V>, backend_type: BackendType) -> Self {
let backend = match backend_type {
BackendType::Memory => MemoryBackend::<K, V>::New(),
};
Cache {
wrapped: wrapped,
backend: Box::new(backend),
}
}
fn get(&mut self, k: &K) -> Option<&V> {
// PROBLEM 1:
// Borrow backend here as immutable
if let Some(v) = self.backend.get(k) {
return Some(v)
}
if let Some(v) = self.wrapped.get(k) {
let cache_k = *k.clone(); // PROBLEM 2: How to clone reference value?
let cache_v = *v.clone(); // PROBLEM 2: How to clone reference value?
// PROBLEM 1:
// Borrow backend here as mutable
self.backend.set(cache_k, cache_v);
return Some(v)
}
None
}
}
pub enum BackendType {
Memory
}
pub struct MemoryBackend<K, V>
where K: std::cmp::Eq + std::hash::Hash
{
data: HashMap<K, V>,
}
impl<K, V> Cacheable<K, V> for MemoryBackend<K, V>
where K: std::cmp::Eq + std::hash::Hash
{
fn get(&self, k: &K) -> Option<&V> {
self.data.get(k)
}
fn set(&mut self, k: K, v: V) {
self.data.insert(k, v);
}
fn del(&mut self, k: &K) {
self.data.remove(k);
}
}
impl<K, V> MemoryBackend<K, V>
where K: std::cmp::Eq + std::hash::Hash
{
fn New() -> Self {
MemoryBackend {
data: HashMap::<K, V>::new(),
}
}
}
Problem 1
Possible coexistence of mutable and immutable references. What would be the best option here?
I tried changing the get method signature to return an Option<V> instead of Option<&V> but that leads me also to the problem 2, for which I can't seem to be able to clone the value of a shared reference.
Problem 2
move occurs because value has type `K`, which does not implement the `Copy` trait
help: consider borrowing here: `&*k.clone()`"
AFAIK I don't want to set Copy trait as bound of V because it might not be a simple type and would much rather clone its value than setting that as an API restriction. I can't seem to work around this.

Answer 1

Problem 1: Possible coexistence of mutable and immutable references. What would be the best option here? I tried changing the get method signature to return an Option<V> instead of Option<&V> but that leads me also to the problem 2, for which I can't seem to be able to clone the value of a shared reference.
You could add a get_or_insert method to the trait, and implement it for MemoryBackend using the hash_map::Entry API:
fn get_or_insert(&mut self, k: K, v: Option<V>) -> Option<&V> {
match self.data.entry(k) {
Entry::Occupied(entry) => Some(entry.into_mut()),
Entry::Vacant(entry) => v.map(|v| &*entry.insert(v)),
}
}
Or, to avoid evaluating v unless it's actually required (which an optimisation pass might already do if the above is inlined), you could instead pass in a function that returns Option<V>:
fn get_or_insert_with(&mut self, k: K, f: &dyn Fn() -> Option<V>) -> Option<&V> {
match self.data.entry(k) {
Entry::Occupied(entry) => Some(entry.into_mut()),
Entry::Vacant(entry) => f().map(|v| &*entry.insert(v)),
}
}
Note that, in order for Cacheable to be object-safe, we have to use the indirection of a function-trait object here (which, again, an optimisation pass might eliminate if the above is inlined).
Problem 2:
"move occurs because value has type K, which does not implement the Copy trait
help: consider borrowing here: &*k.clone()"
AFAIK I don't want to set Copy trait as bound of V because it might not be a simple type and would much rather clone its value than setting that as an API restriction.
So I can't seem to work around this.
You could add K: Clone and V: Clone constraints to the implementation:
impl<'a, K, V> Cache<'a, K, V>
where
K: Clone + std::cmp::Eq + std::hash::Hash + 'static,
V: Clone + 'static,
{
// etc
}
(Playground)