use moka::{Entry, ops::{Op, PerformedOp}};

// For moka::sync::Cache's entry API
// `K` and `V` are the key and value type of the cache.
pub fn and_compute<F>(self, f: F) -> (Option<Entry<K, V>>, PerformedOp)
where
    F: FnOnce(Option<&V> -> Op<V>);

// For moka::future::Cache's entry API
pub async fn and_compute<'a, F, Fut>(self, f: F) -> (Option<Entry<K, V>>, PerformedOp)
where
    F: FnOnce(Option<&'a V>) -> Fut,
    Fut: Future<Output = Op<V>> + 'a;

/// Instructs the `and_compute` method how to modify the cache entry.
pub enum Op<V> {
    /// No-op. Do not modify the cache entry.
    Nop,
    /// Insert or replace the value of the cache entry.
    Put(V),
    /// Invalidate the cache entry.
    Invalidate,
}

/// Will be returned from `and_compute` method to indicate what kind of
/// operation was performed.
pub enum PerformedOp {
    /// The entry did not exist, or already existed but was not modified.
    Nop,
    /// The entry did not exist and inserted.
    Inserted,
    /// The entry already existed and its value was updated.
    Updated,
    /// The entry existed and was invalidated.
    /// Note: If `and_compute` tried to invalidate a not-exiting entry, 
    /// `Nop` will be returned instead of `Invalidated`
    Invalidated,
}

use moka::{future::Cache, ops::{Op, PerformedOp}};

let cache: Cache<String, u64> = Cache::new(100);
let key = "key".to_string();

// maybe_entry: Option<moka::Entry<K, V>>
// op_kind:     moka::op::PerformedOp
let (maybe_entry, performed_op) = cache
    .entry_by_ref(&key)
    .and_compute(|entry| async move {
        match entry {
            // If the entry does not exist, insert a value of 1.
            None => Op::Put(1),
            // If the entry exists, increment the value by 1.
            Some(count) => Op::Put(count.saturating_add(1)),
        }
    })
    .await;

assert_eq!(performed_op, PerformedOp::Inserted);
assert_eq!(maybe_entry.unwrap().into_value(), 1);