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

use super::{EffectContext, Effect, LiftingConfig, EffectResult, GenerationalEnvManager};
use crate::diagnostics::Result;
use crate::eval::Value;

/// The main effect system manager.
///
/// This coordinates effect tracking, automatic lifting, and
/// integration with the evaluator and type system.
#[derive(Debug, Clone)]
pub struct EffectSystem {
    /// Current effect context
    context: EffectContext,
    /// Generational environment manager
    env_manager: GenerationalEnvManager,
    /// Effect lifting configuration
    lifting_config: LiftingConfig,
}

impl EffectSystem {
    /// Creates a new effect system.
    pub fn new() -> Self {
        Self {
            context: EffectContext::pure(),
            env_manager: GenerationalEnvManager::new(),
            lifting_config: LiftingConfig::default(),
        }
    }
    
    /// Creates an effect system with the given configuration.
    pub fn with_config(config: LiftingConfig) -> Self {
        Self {
            context: EffectContext::pure(),
            env_manager: GenerationalEnvManager::new(),
            lifting_config: config,
        }
    }
    
    /// Gets the current effect context.
    pub fn context(&self) -> &EffectContext {
        &self.context
    }
    
    /// Gets a mutable reference to the effect context.
    pub fn context_mut(&mut self) -> &mut EffectContext {
        &mut self.context
    }
    
    /// Gets the generational environment manager.
    pub fn env_manager(&self) -> &GenerationalEnvManager {
        &self.env_manager
    }
    
    /// Gets a mutable reference to the generational environment manager.
    pub fn env_manager_mut(&mut self) -> &mut GenerationalEnvManager {
        &mut self.env_manager
    }
    
    /// Gets the lifting configuration.
    pub fn lifting_config(&self) -> &LiftingConfig {
        &self.lifting_config
    }
    
    /// Enters a new effect context.
    pub fn enter_context(&mut self, effects: Vec<Effect>) -> EffectContext {
        let old_context = self.context.clone();
        for effect in effects {
            self.context.add_effect(effect);
        }
        old_context
    }
    
    /// Exits an effect context, restoring the previous one.
    pub fn exit_context(&mut self, old_context: EffectContext) {
        self.context = old_context;
    }
    
    /// Handles an effect with the current context.
    pub fn handle_effect(&self, effect: &Effect, args: &[Value]) -> Result<EffectResult> {
        if let Some(handler_ref) = self.context.find_handler(effect) {
            handler_ref.handler().handle(effect, args)
        } else {
            Ok(EffectResult::Unhandled)
        }
    }
    
    /// Determines if an operation should be automatically lifted.
    pub fn should_lift(&self, operation: &str, current_effects: &[Effect]) -> Option<Effect> {
        // Check custom rules first
        if let Some(effect) = self.lifting_config.check_custom_rules(operation, current_effects) {
            return Some(effect);
        }
        
        // Check built-in lifting rules
        match operation {
            "display" | "write" | "newline" | "read" | "open-input-file" | "open-output-file" 
                if self.lifting_config.auto_lift_io() => Some(Effect::IO),
            "set!" | "vector-set!" | "string-set!" 
                if self.lifting_config.auto_lift_state() => Some(Effect::State),
            "error" | "raise" | "throw" 
                if self.lifting_config.auto_lift_error() => Some(Effect::Error),
            _ => None,
        }
    }
}

impl Default for EffectSystem {
    fn default() -> Self {
        Self::new()
    }
}