Skip to main content

quilt_gc/
lib.rs

1//! quilt-gc — the GC primitive of a Quilt cell.
2//! 
3//! 3-phase garbage collection: merge similar → decay old → prune weak.
4//! The cell forgets. Forgetting is structural. Forgetting is necessary.
5
6use serde::{Deserialize, Serialize};
7
8#[derive(Debug, Clone, Default, Serialize, Deserialize)]
9pub struct Gc {
10    pub phase: String,
11    pub merged: u64,
12    pub decayed: u64,
13    pub pruned: u64,
14    pub cycles: u64,
15}
16
17impl Gc {
18    pub fn new() -> Self { Self { phase: "ready".to_string(), ..Default::default() } }
19    pub fn merge(&mut self, n: u64) { self.merged += n; self.phase = "merged".to_string(); }
20    pub fn decay(&mut self, n: u64) { self.decayed += n; self.phase = "decayed".to_string(); }
21    pub fn prune(&mut self, n: u64) { self.pruned += n; self.phase = "pruned".to_string(); }
22    pub fn cycle(&mut self, merged: u64, decayed: u64, pruned: u64) {
23        self.merge(merged);
24        self.decay(decayed);
25        self.prune(pruned);
26        self.cycles += 1;
27        self.phase = "ready".to_string();
28    }
29    pub fn total(&self) -> u64 { self.merged + self.decayed + self.pruned }
30}
31
32#[cfg(test)]
33mod tests {
34    use super::*;
35    #[test]
36    fn test_gc_cycle() {
37        let mut gc = Gc::new();
38        gc.cycle(3, 2, 1);
39        assert_eq!(gc.merged, 3);
40        assert_eq!(gc.decayed, 2);
41        assert_eq!(gc.pruned, 1);
42        assert_eq!(gc.cycles, 1);
43        assert_eq!(gc.total(), 6);
44    }
45}