ksl 0.1.7

KSL core library and interpreter
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

//! # ksl::eval
//!
//! Defines some functions related to the evaluation of KSL values.

pub mod apply;
mod pair;
mod sentence;

use crate::{
    Environment,
    eval::{apply::eval_apply, sentence::eval_sentence},
    token::{TokenType, source_to_token},
    value::Value,
};

/// Evaluate the source code.
///
/// # Example
///
/// ```rust
/// fn main() {
///     let source = r#"
/// Let[f, Fun[{x}, Add[x, 1]]];
/// Let[x, 2];
/// f[x]
///     "#;
///     let env = ksl::init_environment();
///     match ksl::eval::eval(source, &env) {
///         Some((value, _)) => assert_eq!(value, ksl::value::Value::Number(3.0)),
///         None => unreachable!(),
///     }
/// }
/// ```
pub fn eval(source: &str, env: &Environment) -> Option<(Value, Environment)> {
    let mut current_val = Value::Unit;
    let mut current_environment = env.clone();
    let mut local_environment = Environment::new();
    if let Some(tokens) = source_to_token(source) {
        for sentence in tokens
            .split(|token| match token.value {
                TokenType::SentenceSeperator => true,
                _ => false,
            })
            .filter(|s| !s.is_empty())
        {
            if let Some((val, new_env)) = eval_sentence(sentence, &current_environment)
                .map(|val| eval_apply(&val, &current_environment))
                .flatten()
            {
                local_environment.extend(new_env.clone());
                current_environment.extend(new_env.clone());
                current_val = val;
            } else {
                return None;
            }
        }
    } else {
        return None;
    }
    Some((current_val, local_environment))
}

/// Extracting the environment in a Lambda object.
pub(crate) fn extract_lambda_env(params: &[String], body: &Value, env: &Environment) -> Environment {
    let mut local_environment = Environment::new();
    let mut current_environment = env.clone();
    match body {
        Value::Identity(id) => {
            if !(params.contains(id) || local_environment.contains_key(id)) {
                if let Some(val) = current_environment.get(id) {
                    let _ = local_environment.insert(id.clone(), val.clone());
                }
            }
        }
        Value::List(elements) => {
            for element in elements.iter() {
                let new_env = extract_lambda_env(params, element, &current_environment);
                local_environment.extend(new_env.clone());
                current_environment.extend(new_env);
            }
        }
        Value::Lambda(inner_params, sub_func, inner_env) => {
            let mut capture = current_environment.clone();
            capture.extend(inner_env.clone());
            let mut all_params = params.to_vec();
            all_params.extend(inner_params.clone());
            let new_env = extract_lambda_env(&all_params, sub_func, &capture);
            local_environment.extend(new_env);
        }
        Value::Apply(arguments, sub_func) => {
            for argument in arguments.iter() {
                let new_env = extract_lambda_env(params, argument, &current_environment);
                local_environment.extend(new_env.clone());
                current_environment.extend(new_env);
            }
            let new_env = extract_lambda_env(params, sub_func, &current_environment);
            local_environment.extend(new_env);
        }
        _ => (),
    }
    local_environment
}