reactive-cache 0.3.5

A lightweight, dependency-aware memoization library with automatic invalidation and lazy recomputation.
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

# ReactiveCache

**Cache smart, update only when it matters.**

[![Crates.io](https://img.shields.io/crates/v/reactive-cache.svg)](https://crates.io/crates/reactive-cache)
[![Docs.rs](https://docs.rs/reactive-cache/badge.svg)](https://docs.rs/reactive-cache)
[![License](https://img.shields.io/crates/l/reactive-cache.svg)](LICENSE)

A lightweight, dependency-aware memoization library with automatic invalidation and lazy recomputation.

---

**ReactiveCache** automatically tracks the relationships between computed values and their data sources.  
When a dependency becomes invalid, all cached results that rely on it are automatically invalidated.  
The next time you access a cached value, it will be recomputed lazily and stored again.

### Features

- **Automatic dependency tracking** – No manual dependency declarations.
- **Lazy recomputation** – Only recompute when accessed after invalidation.
- **Chained invalidation** – Changes ripple through the dependency graph.
- **Lightweight** – Minimal runtime overhead.

### Use cases

- Reactive data models
- Computed properties in UI frameworks
- Configuration and build systems

---

### Signal-Memo-Effect Relationship


ReactiveCache is structured around a clear three-tier reactive model:

Signal(s) → Memo(s) → Effect

Signal (atomic mutable)
|
+--> Memo (derived computation, cached value, lazy)
|
+--> Effect (side-effectful computation, eager)

1. **Signal**  
   Signals are the source of truth in the system. They hold raw values that can change over time.  
   Updating a signal automatically marks any dependent computations as potentially stale.

2. **Memo**  
   Memos are derived, computed values that depend on one or more signals (or other memos).  
   When a signal changes, all memos that depend on it are invalidated.  
   Accessing a memo after invalidation triggers lazy recomputation, ensuring that cached values are always consistent.

3. **Effect**  
   Effects are side-effectful computations that run automatically whenever their dependencies change.  
   They subscribe to signals and memos, reacting to updates without manual intervention.  
   Effects do not produce cached values; instead, they propagate changes outward (e.g., updating UI, logging, or triggering external events).

**Dependency Flow:**  

- **Signals** update their dependents (memos/effects).  
- **Memos** recompute lazily when accessed, maintaining up-to-date derived values.  
- **Effects** automatically react whenever any dependency they use changes.

This separation ensures efficient and predictable propagation: cached computations are only recomputed when needed, while side effects happen immediately when dependencies change.

This three-level model ensures that changes propagate efficiently, only recomputing what is necessary, and automatically triggering side-effects in a controlled and predictable way.