Added more config options and tested recursion

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "density_function_lang"
-version = "3.1.2"
+version = "3.2.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

example/test/main.test

@@ -0,0 +1,35 @@
+template loop_for_index(start, end, step, f) {
+    loop_for_index_impl(start, end, step, start, f, false)
+}
+
+template loop_for_index_impl(start, end, step, current, f, result) {
+    if (current == end || (start + step > start && current >= end) || (start + step < start && current <= end)) {
+        result
+    } else {
+        loop_for_index_impl(start, end, step, builtin.static(current + step), f, f(current))
+    }
+}
+
+template iteration(i) {
+    i // builtin.error("Iteration", i)
+}
+
+export loop_for_index_test = loop_for_index(0, 20, 1, iteration);
+
+template array_fold(array, start_acc, f) {
+    array_fold_impl(array, start_acc, f, 0)
+}
+
+template array_fold_impl(array, acc, f, index) {
+    if (index >= array.length)
+        acc
+    else {
+        array_fold_impl(array, f(acc, builtin.static(array[index])), f, builtin.static(index + 1))
+    }
+}
+
+template array_fold_iteration(acc, element) {
+    builtin.static(acc + element)
+}
+
+export array_fold_test = array_fold([7, 3, 5, 1, 2, 8, 10, 9, 6, 4], 0, array_fold_iteration);

example/test/target/array_fold_test.json

@@ -0,0 +1 @@
+55

example/test/target/loop_for_index_test.json

@@ -0,0 +1 @@
+19

src/compiler/ast.rs

@@ -116,6 +116,11 @@ pub enum Expr {
         receiver: Box<Expr>,
         name: Token,
     },
+    Index {
+        receiver: Box<Expr>,
+        operator: Token,
+        index: Box<Expr>,
+    },
     BuiltinFunctionCall {
         name: Token,
         args: Vec<Expr>,
@@ -144,6 +149,7 @@ impl Debug for Expr {
                     .collect::<Vec<String>>().join(", "))
             },
             Expr::Member { receiver, name } => write!(f, "({:?}.{})", receiver, name.source()),
+            Expr::Index { receiver, index, .. } => write!(f, "({:?}[{:?}])", receiver, index),
             Expr::BuiltinFunctionCall { name, args } => {
                 write!(f, "(builtin.{}({}))", name.source(), args.iter()
                     .map(|expr| format!("{:?}", expr))
@@ -188,7 +194,17 @@ pub struct Template {
     pub file_path: Rc<RefCell<PathBuf>>,
 }
 
-#[derive(Debug)]
+impl PartialEq for Template {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name
+            && self.receiver == other.receiver
+            && self.args == other.args
+            && self.expr == other.expr
+            && self.file_path == other.file_path
+    }
+}
+
+#[derive(Debug, PartialEq)]
 pub struct Module {
     pub name: String,
     pub sub_modules: Vec<Rc<RefCell<Module>>>,