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
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
122
123
124
125
126
127
128
129
130
131
132

use super::Operator;
use crate::{
	error::{EggError, EggResult},
	evaluator::evaluate,
	expression::{self, Value},
	scope::Scope,
};
use alloc::string::{String, ToString};

pub struct Concat;

impl Operator for Concat {
	fn evaluate(&self, args: &[expression::Expression], scope: &mut Scope) -> EggResult<Value> {
		let mut result = String::with_capacity(args.len() * 64);

		for arg in args {
			match evaluate(arg, scope)? {
				Value::String(string) => result.push_str(&string),
				_ => return Err(EggError::OperatorComplaint("Cannot concatenate non-string".to_string())),
			}
		}

		Ok(Value::String(result.into()))
	}
}

pub struct Length;

impl Operator for Length {
	fn evaluate(&self, args: &[expression::Expression], scope: &mut Scope) -> EggResult<Value> {
		// Assert correct length of arguments
		debug_assert_eq!(args.len(), 1);

		// Evaluate
		let res = evaluate(&args[0], scope)?;
		let value = match res {
			Value::String(string) => string.len(),
			_ => return Err(EggError::OperatorComplaint("Cannot get length of non-string".to_string())),
		};

		Ok(Value::Number((value as f32).into()))
	}
}

/// Builtin for slicing and indexing into strings
pub struct Slice;

impl Operator for Slice {
	fn evaluate(&self, args: &[expression::Expression], scope: &mut Scope) -> EggResult<Value> {
		// Assert correct length of arguments
		debug_assert_eq!(args.len(), 3);

		// Evaluate
		let res = evaluate(&args[0], scope)?;

		let base = match res {
			Value::String(string) => string,
			_ => return Err(EggError::OperatorComplaint("Cannot slice non-string".to_string())),
		};

		let mut start = match evaluate(&args[1], scope)? {
			Value::Number(num) => num,
			_ => return Err(EggError::OperatorComplaint("Cannot slice with non-number".to_string())),
		};

		(start.0 < 0.0).then(|| start += base.len() as f32);
		let length = match evaluate(&args[2], scope)? {
			Value::Number(num) => num.0 as usize,
			_ => return Err(EggError::OperatorComplaint("Cannot slice with non-number".to_string())),
		};

		let start = start.0 as usize;
		let result = &base[start..start + length];

		Ok(Value::String(result.into()))
	}
}

/// Converts a String to UpperCase
pub struct ToUpper;

impl Operator for ToUpper {
	fn evaluate(&self, args: &[expression::Expression], scope: &mut Scope) -> EggResult<Value> {
		// Assert correct length of arguments
		debug_assert_eq!(args.len(), 1);

		// Evaluate
		let res = evaluate(&args[0], scope)?;
		let value = match res {
			Value::String(string) => string.to_uppercase(),
			_ => return Err(EggError::OperatorComplaint("Cannot convert non-string to uppercase".to_string())),
		};

		Ok(Value::String(value.into()))
	}
}

/// Converts a String to Upper case
pub struct ToLower;

impl Operator for ToLower {
	fn evaluate(&self, args: &[expression::Expression], scope: &mut Scope) -> EggResult<Value> {
		// Assert correct length of arguments
		debug_assert_eq!(args.len(), 1);

		// Evaluate
		let res = evaluate(&args[0], scope)?;
		let value = match res {
			Value::String(string) => string.to_lowercase(),
			_ => return Err(EggError::OperatorComplaint("Cannot convert non-string to lowercase".to_string())),
		};

		Ok(Value::String(value.into()))
	}
}

/// Trims whitespace from the start and end of a string
pub struct Trim;

impl Operator for Trim {
	fn evaluate(&self, args: &[expression::Expression], scope: &mut Scope) -> EggResult<Value> {
		// Assert correct length of arguments
		debug_assert_eq!(args.len(), 1);

		// Evaluate
		let res = evaluate(&args[0], scope)?;
		match res {
			Value::String(string) => Ok(Value::String(string.trim().into())),
			_ => Err(EggError::OperatorComplaint("Cannot trim non-string".to_string())),
		}
	}
}