dist_agent_lang 1.0.5

A hybrid programming language for decentralized and centralized network integration
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
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

use crate::runtime::scope::Scope;
use crate::runtime::values::Value;

pub type FunctionBody = Box<dyn Fn(&[Value], &mut Scope) -> Result<Value, RuntimeError>>;

pub struct Function {
    pub name: String,
    pub parameters: Vec<String>,
    /// None for cloned built-ins; caller must pass body_override when invoking (e.g. engine resolves by name).
    pub body: Option<FunctionBody>,
}

impl Function {
    pub fn new<F>(name: String, parameters: Vec<String>, body: F) -> Self
    where
        F: Fn(&[Value], &mut Scope) -> Result<Value, RuntimeError> + 'static,
    {
        Self {
            name,
            parameters,
            body: Some(Box::new(body)),
        }
    }

    /// Reference to the body, if present (not a clone).
    pub fn body_ref(&self) -> Option<&FunctionBody> {
        self.body.as_ref()
    }

    /// Call with optional body override so cloned functions can be invoked when the engine resolves by name.
    pub fn call(
        &self,
        args: &[Value],
        scope: &mut Scope,
        body_override: Option<&FunctionBody>,
    ) -> Result<Value, RuntimeError> {
        if args.len() != self.parameters.len() {
            return Err(RuntimeError::ArgumentCountMismatch {
                expected: self.parameters.len(),
                got: args.len(),
            });
        }

        let body = body_override
            .or(self.body.as_ref())
            .ok_or(RuntimeError::FunctionNotClonable)?;

        let mut function_scope = Scope::new_child(scope.clone());
        for (param, arg) in self.parameters.iter().zip(args.iter()) {
            function_scope.set(param.clone(), arg.clone());
        }

        (body)(args, &mut function_scope)
    }
}

impl Clone for Function {
    fn clone(&self) -> Self {
        Self {
            name: self.name.clone(),
            parameters: self.parameters.clone(),
            body: None,
        }
    }
}

#[derive(Debug, thiserror::Error)]
pub enum RuntimeError {
    #[error("Argument count mismatch: expected {expected}, got {got}")]
    ArgumentCountMismatch { expected: usize, got: usize },

    #[error("Function not clonable")]
    FunctionNotClonable,

    #[error("Variable '{0}' not found")]
    VariableNotFound(String),

    #[error("Type error: expected {expected}, got {got}")]
    TypeError { expected: String, got: String },

    #[error("Stack underflow")]
    StackUnderflow,

    #[error("Function '{0}' not found")]
    FunctionNotFound(String),

    #[error("Runtime error: {0}")]
    General(String),

    #[error("Type mismatch in {0}")]
    TypeMismatch(String),

    #[error("Division by zero")]
    DivisionByZero,

    #[error("Unsupported operation: {0}")]
    UnsupportedOperation(String),

    #[error("Permission denied: {0}")]
    PermissionDenied(String),

    #[error("Re-entrancy detected: {0}")]
    ReentrancyDetected(String),

    #[error("Integer overflow")]
    IntegerOverflow,

    #[error("Integer underflow")]
    IntegerUnderflow,

    #[error("Read-only violation")]
    ReadOnlyViolation,

    #[error("Access denied")]
    AccessDenied,

    #[error("Execution timeout: program exceeded maximum execution time")]
    ExecutionTimeout,
}

impl RuntimeError {
    pub fn stack_underflow() -> Self {
        RuntimeError::StackUnderflow
    }

    pub fn function_not_found(name: String) -> Self {
        RuntimeError::FunctionNotFound(name)
    }
}