About how to try_get_with() Arc<Error>

[Cloud33]

Hello, I am a Rust novice, I use moka::future::Cache.

I don't know how to handle the Arc<Error> returned in try_get_with(). I don't know how to convert Arc<Error> into an Error and return it to the front-end

The code is probably:

pub struct UserService{
        pub db: DbPool,
        pub cache: Cache<i64, Arc<User>>,
}
impl UserService{
  async async fn get_cache(&self, id: i64) -> Result<Arc<User>, Error> {
          //// error , return Arc<Error>
          self.cache.try_get_with(proc_id, self.get(proc_id)).await   
  }
  async fn get(&self, id: i64) -> Result<Arc<User>, Error> {
          let user = self.db.read(id).await;
          match proc {
              Ok(proc) => Ok(Arc::new(user)),
              Err(err) => Err(err),
          }
   }
}

get_cache error , return Arc<Error>, not Error
I expect to return to Error, what should I do here

thank you

[tatsuya6502]

Hi.

I don't know how to convert Arc into an Error and return it to the front-end

If your error type Error implements Clone trait, you can create Error from Arc<Error> by cloning it:

use thiserror::Error;

#[derive(Error, Debug, Clone)]
pub enum MyError {
    #[error("db error")]
    DbError,
}

impl UserService {
    async fn get_cache(&self, id: i64) -> Result<Arc<User>, MyError> {
        self.cache
            .try_get_with(id, self.get(id))
            .await
            // Create `MyError` from `Arc<MyError>`.
            .map_err(|e| (*e).clone())
    }
}

Also, Arc provides try_unwrap method, which returns the inner value if the Arc has exactly one strong reference. So you can do the followings:

/// Tries to unwrap the `Arc<T>` and returns the original `T` if successful.
/// Otherwise, returns a clone of the original `T`.
pub(crate) fn unwrap_arc_or_clone<T: Clone>(v: Arc<T>) -> T {
    Arc::try_unwrap(v).unwrap_or_else(|v| (*v).clone())
}

impl UserService {
    async fn get_cache(&self, id: i64) -> Result<Arc<User>, MyError> {
        self.cache
            .try_get_with(id, self.get(id))
            .await
            .map_err(unwrap_arc_or_clone)
    }
}

If your error type does not implement Clone, you will need to change the return type of get_cache from
Result<Arc<User>, Error> to Result<Arc<User>, Arc<Error>>.

This should not be too bad because Arc<T> allows you to call T's methods. For example, you can call source method of Error trait on the Arc directly, or you can use match on the Arc as if it is T by dereferencing it:

let e = Arc::new(MyError::DbError);
// You can call `source` method of `Error` trait on the `Arc` directly.
dbg!(e.source());
// You can also use `match` on the `Arc` as if it is `MyError`
// by dereferencing it.
match *e {
    MyError::DbError => todo!(),
}

[Cloud33]

thank you