egglang 0.3.5

The Egg Programming Language From Eloquent JavaScript, but in Rust
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

use crate::{
	error::{EggError, EggResult},
	evaluator::evaluate,
	expression::{Expression, Value},
	scope::Scope,
};
use alloc::string::ToString;

// Checks for equality
pub struct Equals;

impl super::Operator for Equals {
	fn evaluate(&self, args: &[Expression], scope: &mut Scope) -> EggResult<Value> {
		debug_assert_eq!(args.len(), 2);

		let val1 = evaluate(&args[0], scope)?;
		let val2 = evaluate(&args[1], scope)?;

		Ok((val1 == val2).into())
	}
}

// Checks for inequality
pub struct NotEquals;

impl super::Operator for NotEquals {
	fn evaluate(&self, args: &[Expression], scope: &mut Scope) -> EggResult<Value> {
		debug_assert_eq!(args.len(), 2);

		let val1 = evaluate(&args[0], scope)?;
		let val2 = evaluate(&args[1], scope)?;

		Ok((val1 != val2).into())
	}
}

// Greater than
pub struct GreaterThan;

impl super::Operator for GreaterThan {
	fn evaluate(&self, args: &[Expression], scope: &mut Scope) -> EggResult<Value> {
		debug_assert_eq!(args.len(), 2);

		let val1 = evaluate(&args[0], scope)?;
		let val2 = evaluate(&args[1], scope)?;

		match (val1, val2) {
			(Value::Number(a), Value::Number(b)) => Ok((a > b).into()),
			_ => Err(EggError::OperatorComplaint("please provide numbers as arguments for mathematical operations".to_string())),
		}
	}
}

/// Lesser than
pub struct LessThan;

impl super::Operator for LessThan {
	fn evaluate(&self, args: &[Expression], scope: &mut Scope) -> EggResult<Value> {
		debug_assert_eq!(args.len(), 2);

		let val1 = evaluate(&args[0], scope)?;
		let val2 = evaluate(&args[1], scope)?;

		match (val1, val2) {
			(Value::Number(a), Value::Number(b)) => Ok((a < b).into()),
			_ => Err(EggError::OperatorComplaint("please provide numbers as arguments for mathematical operations".to_string())),
		}
	}
}

/// Checks if the value is nil
pub struct IsNil;

impl super::Operator for IsNil {
	fn evaluate(&self, args: &[Expression], scope: &mut Scope) -> EggResult<Value> {
		debug_assert_eq!(args.len(), 1);

		Ok(matches!(evaluate(&args[0], scope)?, Value::Nil).into())
	}
}