evar 0.1.1

Modern ergonomic math calculator inspired by eva
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

use super::{Context, EvalError, Expr, Value};
use std::rc::Rc;

#[derive(Clone)]
pub struct Function(Rc<FunctionInner>);

impl Function {
    pub fn call(&self, args: Vec<Value>, context: &mut Context) -> Result<Value, EvalError> {
        self.0.call(args, context)
    }

    pub fn new_internal(arg_names: Vec<String>, body: Expr) -> Function {
        Function(Rc::new(FunctionInner::Internal {
            arity: arg_names.len(),
            arg_names,
            body,
        }))
    }

    pub fn new_external(
        arity: usize,
        body: fn(Vec<Value>) -> Result<Value, EvalError>,
    ) -> Function {
        Function(Rc::new(FunctionInner::External { arity, body }))
    }

    pub fn is_external(&self) -> bool {
        matches!(&*self.0, FunctionInner::External { arity: _, body: _ })
    }
}

enum FunctionInner {
    External {
        arity: usize,
        body: fn(Vec<Value>) -> Result<Value, EvalError>,
    },
    Internal {
        arity: usize,
        arg_names: Vec<String>,
        body: Expr,
    },
}

impl FunctionInner {
    pub fn call(&self, args: Vec<Value>, context: &mut Context) -> Result<Value, EvalError> {
        match self {
            FunctionInner::External { arity, body } => {
                if args.len() == *arity {
                    body(args)
                } else {
                    Err(EvalError::InvalidNumberOfArguments(*arity, args.len()))
                }
            }
            FunctionInner::Internal {
                arity,
                arg_names,
                body,
            } => {
                if args.len() == *arity {
                    context.extend();

                    for (arg_name, arg) in arg_names.iter().zip(args.into_iter()) {
                        context.set_variable(arg_name, arg);
                    }
                    body.eval(context)
                } else {
                    Err(EvalError::InvalidNumberOfArguments(*arity, args.len()))
                }
            }
        }
    }
}