lambdust 0.1.1

A Scheme dialect with gradual typing and effect systems
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

//! In-memory implementation of continuation repository

use crate::eval::continuation_domain::{CapturedContinuation, ContinuationId};
use crate::diagnostics::{Result, Error};
use std::collections::HashMap;

use super::{
    continuation_repository::ContinuationRepository,
    repository_configuration::RepositoryConfiguration,
};

/// In-memory implementation of continuation repository
#[derive(Debug)]
pub struct InMemoryContinuationRepository {
    /// Storage for continuations
    continuations: HashMap<ContinuationId, CapturedContinuation>,
    
    /// Configuration
    config: RepositoryConfiguration,
}

impl ContinuationRepository for InMemoryContinuationRepository {
    fn store(&mut self, continuation: CapturedContinuation) -> Result<ContinuationId> {
        let id = continuation.id;
        
        // Check if we're at capacity
        if self.continuations.len() >= self.config.max_continuations {
            if self.config.auto_gc_enabled {
                self.garbage_collect(0)?; // Force GC
            } else {
                return Err(Box::new(Error::runtime_error(
                    "Continuation repository at capacity".to_string(),
                    None,
                )));
            }
        }
        
        self.continuations.insert(id, continuation);
        Ok(id)
    }
    
    fn find_by_id(&self, id: ContinuationId) -> Option<CapturedContinuation> {
        self.continuations.get(&id).cloned()
    }
    
    fn remove(&mut self, id: ContinuationId) -> Result<()> {
        self.continuations.remove(&id);
        Ok(())
    }
    
    fn list_all(&self) -> Vec<ContinuationId> {
        self.continuations.keys().copied().collect()
    }
    
    fn garbage_collect(&mut self, current_generation: u64) -> Result<usize> {
        let initial_count = self.continuations.len();
        
        // Remove continuations that are too old or already invoked
        self.continuations.retain(|_id, cont| {
            !cont.is_invoked && 
            (current_generation.saturating_sub(cont.metadata.generation) <= self.config.gc_threshold)
        });
        
        let collected = initial_count - self.continuations.len();
        Ok(collected)
    }
}