https://github.com/omid/kash
Function cache and memoization library for Rust
https://github.com/omid/kash
cache caching function function-memoization memoization memoize memoizer rust rust-caching rust-lang rustlang
Last synced: 10 months ago
JSON representation
Function cache and memoization library for Rust
- Host: GitHub
- URL: https://github.com/omid/kash
- Owner: omid
- License: mit
- Created: 2024-08-12T10:41:48.000Z (over 1 year ago)
- Default Branch: master
- Last Pushed: 2024-10-28T14:58:58.000Z (about 1 year ago)
- Last Synced: 2025-03-19T04:14:22.301Z (10 months ago)
- Topics: cache, caching, function, function-memoization, memoization, memoize, memoizer, rust, rust-caching, rust-lang, rustlang
- Language: Rust
- Homepage: https://crates.io/crates/kash
- Size: 750 KB
- Stars: 5
- Watchers: 1
- Forks: 0
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- Contributing: CONTRIBUTING.md
- License: LICENSE
Awesome Lists containing this project
README
# Kash
[](https://crates.io/crates/kash)
[](https://crates.io/crates/kash)
[](https://docs.rs/kash)
[](https://deps.rs/crate/kash)
Caching structures and simplified function memoization, using [`#[kash]`](kash) macro.
```rust
use kash::kash;
/// Defines a function named `fib` that uses a cache implicitly named `FIB`.
/// By default, the cache will be the function's name in all caps.
#[kash]
fn fib(n: u64) -> u64 {
if n == 0 || n == 1 { return n }
fib(n-1) + fib(n-2)
}
```
Or if you want to limit the size and time-to-live:
```rust
use kash::kash;
const TTL: u64 = 1000;
#[kash(size = "100", ttl = "TTL")]
fn fib(n: u64) -> u64 {
if n == 0 || n == 1 { return n }
fib(n-1) + fib(n-2)
}
```
## Features
- `default`: Includes `ahash` feature.
- `ahash`: Enable `ahash` hasher as default hashing algorithm.
- `async`: Include support for async functions.
- `redis_store`: Include Redis cache store.
- `redis_tokio`: Include async Redis support using `tokio` and `tokio` tls support, implies `redis_store` and `async`.
- `redis_connection_manager`: Enable the optional `connection-manager` feature of `redis`. Any async redis caches created
will use a connection manager instead of a `MultiplexedConnection`.
- `redis_ahash`: Enable the optional `ahash` feature of `redis`.
- `disk_store`: Include disk cache store.
----
```rust
use std::thread::sleep;
use std::time::Duration;
use kash::kash;
/// Use an explicit cache-type with a custom creation block and custom cache-key generating block
#[kash(
size = "100",
key(ty = "String", expr = r#"{ format!("{}{}", a, b) }"#)
)]
fn keyed(a: &str, b: &str) -> usize {
let size = a.len() + b.len();
sleep(Duration::new(size as u64, 0));
size
}
```
----
```rust
use kash::{kash, RedisCacheError};
use kash::AsyncRedisCache;
use thiserror::Error;
#[derive(Error, Debug, PartialEq, Clone)]
enum ExampleError {
#[error("error with redis cache `{0}`")]
RedisError(String),
}
impl From for ExampleError {
fn from(e: RedisCacheError) -> Self {
ExampleError::RedisError(format!("{:?}", e))
}
}
/// Cache the results of an async function in redis. Cache
/// keys will be prefixed with `cache_redis_prefix`.
#[kash(redis)]
async fn async_kash_sleep_secs(secs: u64) -> Result {
std::thread::sleep(std::time::Duration::from_secs(secs));
Ok(secs.to_string())
}
```
----
```rust
use kash::{kash, DiskCacheError};
use kash::DiskCache;
use thiserror::Error;
#[derive(Error, Debug, PartialEq, Clone)]
enum ExampleError {
#[error("error with disk cache `{0}`")]
DiskError(String),
}
impl From for ExampleError {
fn from(e: DiskCacheError) -> Self {
ExampleError::DiskError(format!("{:?}", e))
}
}
/// Cache the results of a function on disk.
/// Cache files will be stored under the system cache dir
/// unless otherwise specified with `dir` or the `create` argument.
#[kash(disk)]
fn kash_sleep_secs(secs: u64) -> Result {
std::thread::sleep(std::time::Duration::from_secs(secs));
Ok(secs.to_string())
}
```
Functions defined via macros will have their result, cached using the
function's arguments as a key by default.
When a macro-defined function is called, the function's cache is first checked for an already
computed (and still valid) value before evaluating the function body.
See [`examples`](https://github.com/omid/kash/tree/master/examples) directory for more examples.
## License
MIT