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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! # ksl::eval::pair
//!
//! Defines functions that parse pairs of parts of a token stream,
//! such as function brackets and list brackets.

use crate::{
    Environment,
    token::{Token, TokenType},
    value::Value,
};

/// The type of Token pair.
#[derive(Debug, PartialEq)]
pub(crate) enum PairType {
    Function,
    List,
}

/// Parses the paired parts of the token stream.
pub(crate) fn eval_pair(tokens: &[Token], env: &Environment, pair_type: PairType) -> Option<(Vec<Value>, usize)> {
    let mut token_index: usize = 0;
    let mut is_closed = false;
    let mut is_checked = false;
    let mut vals: Vec<Value> = Vec::new();
    while let Some(token) = tokens.get(token_index) {
        match &token.value {
            TokenType::Atom(a) if !is_checked => {
                is_checked = true;
                token_index += 1;
                vals.push(Value::Atom(a.clone()));
            }
            TokenType::Number(n) if !is_checked => {
                is_checked = true;
                token_index += 1;
                vals.push(Value::Number(n.clone()));
            }
            TokenType::String(s) if !is_checked => {
                is_checked = true;
                token_index += 1;
                vals.push(Value::String(s.clone()));
            }
            TokenType::Char(c) if !is_checked => {
                is_checked = true;
                token_index += 1;
                vals.push(Value::String(String::from(*c as char)));
            }
            TokenType::Identity(id) if !is_checked => {
                is_checked = true;
                if let Some(tok) = tokens.get(token_index + 1) {
                    match tok.value {
                        TokenType::FuncListOpen => {
                            token_index += 1;
                            let arguments = eval_pair(&tokens[(token_index + 1)..], env, PairType::Function);
                            if let Some((args, bias)) = arguments {
                                token_index += bias + 1;
                                vals.push(Value::Apply(args, Box::new(Value::Identity(id.clone()))));
                            } else {
                                eprintln!(
                                    concat!(
                                        "Error[ksl::eval::eval_pair]: ",
                                        "Failed to apply function `{}`."
                                    ),
                                    id
                                );
                                return None;
                            }
                        }
                        _ => {
                            token_index += 1;
                            vals.push(Value::Identity(id.clone()));
                        }
                    }
                }
            }
            TokenType::ListOpen if !is_checked => {
                is_checked = true;
                let inner_list = eval_pair(&tokens[(token_index + 1)..], env, PairType::List);
                if let Some((contents, bias)) = inner_list {
                    token_index += bias + 1;
                    vals.push(Value::List(contents));
                } else {
                    eprintln!(concat!(
                        "Error[ksl::eval::eval_pair]: ",
                        "Failed to get nested list."
                    ),);
                    return None;
                }
            }
            TokenType::Seperator if is_checked => {
                is_checked = false;
                token_index += 1;
            }
            TokenType::FuncListClose if pair_type == PairType::Function => {
                is_closed = true;
                token_index += 1;
                break;
            }
            TokenType::ListClose if pair_type == PairType::List => {
                is_closed = true;
                token_index += 1;
                break;
            }
            _ => {
                eprintln!(
                    concat!(
                        "Error[ksl::eval::eval_pair]: ",
                        "Unknown token `{:?}` at ({}, {})."
                    ),
                    token.value, token.position.0.0, token.position.0.1
                );
                return None;
            }
        }
    }
    if is_closed {
        Some((vals, token_index))
    } else {
        eprintln!(
            concat!("Error[ksl::eval::eval_pair]: ", "Unclosed pair of {:?}."),
            pair_type
        );
        None
    }
}