mangle 0.0.5

Exolang that can take any utf8 text as valid code and return some result out of it
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

use rustyline::error::ReadlineError;
use rustyline::Editor;

extern crate dirs;
use std::fs;
use unicode_segmentation::UnicodeSegmentation;

struct Value {
    value: String,
    type_: String,
}

struct OpResult {
    result: Result<String, String>,
    assignment: bool,
    assign_to: String,
    assign_value: Value,
}

struct Operator {
    num_args: usize,
    func: fn(Vec<String>) -> OpResult,
}

fn get_operator(op: &str) -> Option<Operator> {
    match op.graphemes(true).count() {
    3 => Some(Operator {  // 0
        num_args: 1,
        func: |args| {
            let mut result = OpResult {
                result: Ok(args[0].clone()),
                assignment: false,
                assign_to: String::new(),
                assign_value: Value {
                    value: String::new(),
                    type_: String::new(),
                },
            };
            result
        },
    })
        _ => None,
}

struct Scope {}

struct Interpreter {
    word_separator: char,
    scope: Scope,
}

impl Interpreter {
    fn new(word_separator: char) -> Interpreter {
        Interpreter {
            scope: Scope {},
            word_separator,
        }
    }

    fn eval(&mut self, input: &str) -> Result<String, String> {
        let inputlist = input.split(self.word_separator).collect::<Vec<&str>>();
        // OP var1 var2
        match inputlist[..] {
            [op, var1, var2, ..] => Ok(format!("{} {} {}", var1, op, var2)),
            _ => Err(format!("{}", input)),
        }
    }
}

fn make_cache() -> Result<String, std::io::Error> {
    let system_cache_dir = dirs::cache_dir().unwrap();
    let cache_path = system_cache_dir.join("mangle");
    fs::create_dir_all(&cache_path)?;
    Ok(cache_path.to_str().unwrap().to_string())
}

struct Context {
    cache_dir: String,
}

fn repl(context: Context) {
    // `()` can be used when no completer is required
    let mut rl = Editor::<()>::new();
    let cache_file_path = context.cache_dir.clone() + "/history";
    if rl.load_history(&cache_file_path).is_err() {
        println!("No previous history.");
    }
    let mut interpreter = Interpreter::new(' ');
    loop {
        let readline = rl.readline(">> ");
        match readline {
            Ok(line) => {
                rl.add_history_entry(line.as_str());
                let result = match interpreter.eval(&line) {
                    Ok(result) => result,
                    Err(err) => err,
                };
                println!("Line: {}", result);
            }
            Err(ReadlineError::Interrupted) => {
                println!("CTRL-C");
                break;
            }
            Err(ReadlineError::Eof) => {
                println!("CTRL-D");
                break;
            }
            Err(err) => {
                println!("Error: {:?}", err);
                break;
            }
        }
    }
    rl.save_history(&cache_file_path).unwrap();
}

fn main() {
    let cache_dir = make_cache().unwrap();
    let context = Context { cache_dir };
    repl(context);
}