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
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use crate::eval::continuation_domain::{
    CapturedContinuation, ContinuationId, ContinuationRepository,
};
use crate::diagnostics::{Result, Error};
use super::{MockRepositoryBehavior, RepositoryCall};
use std::collections::HashMap;
use std::sync::{Arc, Mutex};

/// Mock continuation repository for testing
#[derive(Debug, Default)]
pub struct MockContinuationRepository {
    /// Mock storage
    storage: Arc<Mutex<HashMap<ContinuationId, CapturedContinuation>>>,
    
    /// Mock behavior configuration
    behavior: MockRepositoryBehavior,
    
    /// Call tracking
    call_log: Arc<Mutex<Vec<RepositoryCall>>>,
}

impl MockContinuationRepository {
    /// Create a new mock repository
    #[allow(clippy::arc_with_non_send_sync)]
    pub fn new() -> Self {
        Self {
            storage: Arc::new(Mutex::new(HashMap::new())),
            behavior: MockRepositoryBehavior::default(),
            call_log: Arc::new(Mutex::new(Vec::new())),
        }
    }
    
    /// Create with custom behavior
    #[allow(clippy::arc_with_non_send_sync)]
    pub fn with_behavior(behavior: MockRepositoryBehavior) -> Self {
        Self {
            storage: Arc::new(Mutex::new(HashMap::new())),
            behavior,
            call_log: Arc::new(Mutex::new(Vec::new())),
        }
    }
    
    /// Get call log for assertions
    pub fn call_log(&self) -> Vec<RepositoryCall> {
        self.call_log.lock().unwrap().clone()
    }
    
    /// Clear call log
    pub fn clear_call_log(&self) {
        self.call_log.lock().unwrap().clear();
    }
    
    /// Get number of stored continuations
    pub fn storage_size(&self) -> usize {
        self.storage.lock().unwrap().len()
    }
}

impl ContinuationRepository for MockContinuationRepository {
    fn store(&mut self, continuation: CapturedContinuation) -> Result<ContinuationId> {
        // Log the call
        self.call_log.lock().unwrap().push(RepositoryCall::Store(continuation.id));
        
        // Simulate failure if configured
        if self.behavior.store_should_fail {
            return Err(Box::new(Error::runtime_error(
                "Mock repository configured to fail".to_string(),
                None,
            )));
        }
        
        // Check capacity
        if let Some(max_cap) = self.behavior.max_capacity {
            if self.storage.lock().unwrap().len() >= max_cap {
                return Err(Box::new(Error::runtime_error(
                    "Mock repository at capacity".to_string(),
                    None,
                )));
            }
        }
        
        // Simulate latency
        if self.behavior.simulated_latency_ms > 0 {
            std::thread::sleep(std::time::Duration::from_millis(self.behavior.simulated_latency_ms));
        }
        
        let id = continuation.id;
        self.storage.lock().unwrap().insert(id, continuation);
        Ok(id)
    }
    
    fn find_by_id(&self, id: ContinuationId) -> Option<CapturedContinuation> {
        // Log the call
        self.call_log.lock().unwrap().push(RepositoryCall::Find(id));
        
        // Simulate failure if configured
        if self.behavior.find_should_fail {
            return None;
        }
        
        // Simulate latency
        if self.behavior.simulated_latency_ms > 0 {
            std::thread::sleep(std::time::Duration::from_millis(self.behavior.simulated_latency_ms));
        }
        
        self.storage.lock().unwrap().get(&id).cloned()
    }
    
    fn remove(&mut self, id: ContinuationId) -> Result<()> {
        self.call_log.lock().unwrap().push(RepositoryCall::Remove(id));
        self.storage.lock().unwrap().remove(&id);
        Ok(())
    }
    
    fn list_all(&self) -> Vec<ContinuationId> {
        self.call_log.lock().unwrap().push(RepositoryCall::List);
        self.storage.lock().unwrap().keys().copied().collect()
    }
    
    fn garbage_collect(&mut self, current_generation: u64) -> Result<usize> {
        self.call_log.lock().unwrap().push(RepositoryCall::GarbageCollect(current_generation));
        
        let initial_size = self.storage.lock().unwrap().len();
        
        // Simple GC simulation - remove old continuations
        self.storage.lock().unwrap().retain(|_id, cont| {
            cont.metadata.generation + 5 > current_generation // Keep recent ones
        });
        
        let final_size = self.storage.lock().unwrap().len();
        Ok(initial_size - final_size)
    }
}