kash 0.7.1

Function and method cache and memoization
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

#![cfg(feature = "disk_store")]
#![allow(clippy::unwrap_used)]
/*
run with required features:
    cargo run --example disk --features "disk_store"
 */

use kash::{DiskCacheError, kash};
use std::io;
use std::io::Write;
use std::time::Duration;
use thiserror::Error;

#[derive(Error, Debug, PartialEq, Clone)]
enum ExampleError {
    #[error("error with disk cache `{0}`")]
    DiskError(String),
    #[error("error count `{0}`")]
    Count(i32),
}

impl From<DiskCacheError> for ExampleError {
    fn from(e: DiskCacheError) -> Self {
        ExampleError::DiskError(format!("{e:?}"))
    }
}

// When the macro constructs your DiskCache instance, the default
// cache files will be stored under $system_cache_dir/kash_disk_cache/
#[allow(clippy::unnecessary_wraps)]
#[kash(disk, ttl = "30")]
fn kash_sleep_secs(secs: u64) -> Result<i32, ExampleError> {
    std::thread::sleep(Duration::from_secs(secs));
    Ok(5)
}

#[kash(disk, ttl = "1", option)]
fn kash_disk_optional(n: u32) -> Result<Option<u32>, ExampleError> {
    std::thread::sleep(Duration::from_secs(2));
    if n < 5 {
        Ok(Some(n))
    } else {
        Err(ExampleError::Count(1))
    }
}

#[kash(disk, ttl = "1", result)]
fn kash_disk_result(n: u32) -> Result<u32, ExampleError> {
    std::thread::sleep(Duration::from_secs(2));
    if n < 5 {
        Ok(n)
    } else {
        Err(ExampleError::Count(1))
    }
}

fn main() {
    use kash::IOKash;

    print!("1. first sync call with a 2-second sleep...");
    io::stdout().flush().unwrap();
    assert_eq!(kash_disk_optional(1), Ok(Some(1)));
    println!("done");
    print!("second sync call with a 2-second sleep (it should be fast)...");
    io::stdout().flush().unwrap();
    assert_eq!(kash_disk_optional(1), Ok(Some(1)));
    println!("done");
    io::stdout().flush().unwrap();

    print!("1. first sync call with a 2-second sleep...");
    io::stdout().flush().unwrap();
    assert_eq!(kash_disk_optional(5), Err(ExampleError::Count(1)));
    println!("done");
    print!("second sync call with a 1-second sleep (it should be still slow)...");
    io::stdout().flush().unwrap();
    assert_eq!(kash_disk_optional(6), Err(ExampleError::Count(1)));
    println!("done");
    io::stdout().flush().unwrap();

    //////////////////////////////////////
    print!("1. first sync call with a 2-second sleep...");
    io::stdout().flush().unwrap();
    assert_eq!(kash_disk_result(1), Ok(1));
    println!("done");
    print!("second sync call with a 2-second sleep (it should be fast)...");
    io::stdout().flush().unwrap();
    assert_eq!(kash_disk_result(1), Ok(1));
    println!("done");
    io::stdout().flush().unwrap();

    print!("1. first sync call with a 2-second sleep...");
    io::stdout().flush().unwrap();
    assert_eq!(kash_disk_result(5), Err(ExampleError::Count(1)));
    println!("done");
    print!("second sync call with a 1-second sleep (it should be still slow)...");
    io::stdout().flush().unwrap();
    assert_eq!(kash_disk_result(6), Err(ExampleError::Count(1)));
    println!("done");
    io::stdout().flush().unwrap();

    //////////////////////////////////////
    print!("1. first sync call with a 2-second sleep...");
    io::stdout().flush().unwrap();
    kash_sleep_secs(2).unwrap();
    println!("done");
    print!("second sync call with a 2-second sleep (it should be fast)...");
    io::stdout().flush().unwrap();
    kash_sleep_secs(2).unwrap();
    println!("done");

    KASH_SLEEP_SECS.remove(&2).unwrap();
    print!("third sync call with a 2-second sleep (slow, after cache-remove)...");
    io::stdout().flush().unwrap();
    kash_sleep_secs(2).unwrap();
    println!("done");
}