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

//! # ksl::builtin::apply
//!
//! Built-in function `Apply`.

use crate::{Environment, builtin::eval_builtin, eval::apply::eval_apply, value::Value};

pub(crate) fn builtin(args: &[Value], env: &Environment) -> Option<(Value, Environment)> {
    let mut current_environment = env.clone();
    let mut local_environment = Environment::new();

    if let [func, arguments @ ..] = &args[..] {
        let mut eval_args = Vec::with_capacity(arguments.len());
        for argument in arguments.iter() {
            if let Some((new_arg, new_env)) = eval_apply(argument, &current_environment) {
                local_environment.extend(new_env.clone());
                current_environment.extend(new_env);
                eval_args.push(new_arg);
            } else {
                eprintln!(
                    concat!(
                        "Error[ksl::builtin::apply]: ",
                        "Cannot evaluate expression {:?}."
                    ),
                    argument
                );
                return None;
            }
        }
        match eval_apply(func, &current_environment) {
            Some((Value::Identity(id), _)) => {
                if let Some(func_body) = current_environment.get(&id) {
                    eval_apply(
                        &Value::Apply(eval_args, Box::new(func_body.clone())),
                        &current_environment,
                    )
                } else {
                    eprintln!("Error[ksl::builtin::apply]: Symbol `{}` is not bound.", id);
                    None
                }
            }
            Some((lambda @ Value::Lambda(_, _, _), _)) => eval_apply(
                &Value::Apply(eval_args, Box::new(lambda)),
                &current_environment,
            ),
            Some((Value::Builtin(name), _)) => eval_builtin(name, &eval_args, &current_environment),
            Some((plugin @ Value::Plugin(_, _), _)) => eval_apply(
                &Value::Apply(arguments.to_vec(), Box::new(plugin)),
                &current_environment,
            ),
            Some((e, _)) => {
                eprintln!(
                    concat!(
                        "Error[ksl::builtin::apply]: ",
                        "`{:?}` is not an applicable value.",
                    ),
                    e
                );
                None
            }
            None => {
                eprintln!(
                    concat!(
                        "Error[ksl::builtin::apply]: ",
                        "Cannot evaluate expression {:?}."
                    ),
                    func
                );
                None
            }
        }
    } else {
        eprintln!(
            concat!(
                "Error[ksl::builtin::apply]: ",
                "Only accepts an applicable value ",
                "and a series of arbitrary values as arguments, ",
                "but {:?} were passed."
            ),
            args
        );
        None
    }
}