val 0.4.0

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

use super::*;

#[derive(Clone, Debug)]
pub enum Function<'src> {
  Builtin {
    arity: BuiltinArity,
    function: BuiltinFunction,
    name: &'src str,
  },
  UserDefined {
    body: Vec<Spanned<Statement<'src>>>,
    environment: Environment<'src>,
    name: Option<&'src str>,
    parameters: Vec<&'src str>,
  },
}

impl<'src> Function<'src> {
  pub(crate) fn call(
    &self,
    arguments: Vec<Value<'src>>,
    config: Config,
    span: Span,
  ) -> Result<Value<'src>, Error> {
    self.check_arity(arguments.len(), span)?;

    match self {
      Self::Builtin { function, .. } => {
        function.call(&BuiltinFunctionPayload {
          arguments,
          config,
          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.iter()) {
          call_environment.add_symbol(parameter, argument.clone());
        }

        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.unwrap_or("<anonymous>"),
    }
  }
}

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