try_get_with always runs init future about moka HOT 4 CLOSED

use futures::future;
use std::time::Duration;

async fn init(value: u32) -> u32 {
    println!("init triggered with {}", value);
    tokio::time::sleep(Duration::from_millis(1000)).await;
    println!("init ran to completion");
    value
}

#[tokio::main]
async fn main() {
    // We do not do `.await` on the  `_future`, but the init future
    // will be resolved. This is because `ok` expects a `u32` value
    // as the argument, rather than `impl Future<Output=u32>`.
    let _future = future::ok::<_, u32>(init(2).await);
    let _future = future::ok::<_, u32>(init(3).await);
}

use moka::future::Cache;
use std::convert::Infallible;
use std::hash::Hash;
use std::path::PathBuf;
use std::time::Duration;

async fn init<K: Hash + Eq + Send + Sync + Clone + 'static>(
    cache: Cache<K, u32>,
    key: &K,
    value: u32,
) -> u32 {
    if cache.contains_key(&key) {
        println!("cache contains key but init triggered anyway");
    }
    tokio::time::sleep(Duration::from_millis(1000)).await;
    println!("init ran to completion");
    value
}

fn check_result(result: u32) {
    println!("result: {:?}", &result);
    println!(
        "result was returned from {}",
        if result == 1 {
            "cache"
        } else {
            "init function"
        }
    );
}

#[tokio::main]
async fn main() {
    let cache = Cache::new(100);

    let key = PathBuf::from("asdf");

    cache.insert(key.clone(), 1).await;

    println!("--- checking try_get_with_by_ref ---");

    let result = cache
        .try_get_with_by_ref(&key, async {
            Ok(init(cache.clone(), &key, 2).await) as Result<u32, Infallible>
        })
        .await
        .unwrap();

    check_result(result);

    println!("--- checking try_get_with ---");

    let result = cache
        .try_get_with(key.clone(), async {
            Ok(init(cache.clone(), &key, 3).await) as Result<u32, Infallible>
        })
        .await
        .unwrap();

    check_result(result);

    println!("--- checking get_with ---");

    let result = cache
        .get_with(key.clone(), init(cache.clone(), &key, 4))
        .await;

    check_result(result);
}