val 0.4.2

An arbitrary precision calculator language
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

use super::*;

#[derive(Clone, Debug)]
pub enum Function {
  Builtin {
    arity: BuiltinArity,
    function: fn(&BuiltinFunctionPayload) -> Result<Value, Error>,
    name: &'static str,
  },
  UserDefined {
    body: Vec<Spanned<Statement>>,
    environment: Environment,
    identity: Rc<()>,
    name: Option<String>,
    parameters: Vec<String>,
  },
}

impl Function {
  pub(crate) fn call(
    &self,
    arguments: Vec<Value>,
    config: Config,
    span: Span,
  ) -> Result<Value, Error> {
    match self {
      Self::Builtin { function, name, .. } => {
        function(&BuiltinFunctionPayload {
          arguments,
          config,
          name,
          span,
        })
      }
      Self::UserDefined {
        body,
        environment,
        name,
        parameters,
        ..
      } => {
        let call_environment = Environment::with_parent(environment.clone());

        if let Some(name) = name {
          call_environment.add_function(name, self.clone());
        }

        for (parameter, argument) in parameters.iter().zip(arguments) {
          call_environment.add_symbol(parameter, argument);
        }

        Evaluator::from(call_environment).enter_function(|evaluator| {
          match evaluator.evaluate_statements(body)? {
            Completion::Return(value) | Completion::Value(value) => Ok(value),
            Completion::Break | Completion::Continue => Ok(Value::Null),
          }
        })
      }
    }
  }

  pub(crate) fn check_arity(
    &self,
    len: usize,
    span: Span,
  ) -> Result<(), Error> {
    match self {
      Self::Builtin { arity, name, .. } => arity.check(name, len, span),
      Self::UserDefined { parameters, .. } => {
        if parameters.len() == len {
          return Ok(());
        }

        Err(Error::new(
          span,
          format!(
            "Function `{}` expects {} arguments, got {}",
            self.name(),
            parameters.len(),
            len
          ),
        ))
      }
    }
  }

  pub(crate) fn name(&self) -> &str {
    match self {
      Self::Builtin { name, .. } => name,
      Self::UserDefined { name, .. } => {
        name.as_deref().unwrap_or("<anonymous>")
      }
    }
  }
}

impl PartialEq for Function {
  fn eq(&self, other: &Self) -> bool {
    match (self, other) {
      (Self::Builtin { name: a, .. }, Self::Builtin { name: b, .. }) => a == b,
      (
        Self::UserDefined { identity: a, .. },
        Self::UserDefined { identity: b, .. },
      ) => Rc::ptr_eq(a, b),
      _ => false,
    }
  }
}