add filter buildin

Author: Turtel216

README.md

@@ -19,7 +19,6 @@
 ### Standard Library:
 
 > [!NOTE]  
-> `filter` and `sort` are not implemented yet.
 
 - **I/O**: 
   - `print` - Prints a value to the console.
@@ -29,8 +28,7 @@
   - `tail` - Returns all elements of an array except the first.
   - `get` - Returns the element of an array specified by its index.
   - `map` - Applies a function to each element of an array and returns a new array.
-  - `filter` - Filters an array based on a predicate function.
-  - `sort` - Sorts an array.
+  - `filter` - Filters an array based on a predicate function and returns a new (filtered)array.
   - `reverse` - Reverses an array.
 - **Functional Utilities**: 
   - `fold` - Reduces an array to a single value using a function.

src/evaluator/builtins.rs

@@ -281,9 +281,69 @@ fn lang_map(args: Vec<Object>) -> Object {
     }
 }
 
-// TODO
 fn lang_filter(args: Vec<Object>) -> Object {
-    Object::Error(String::from("TODO: filter is not implemented yet"))
+    if args.len() != 2 {
+        return Object::Error(format!(
+            "wrong number of arguments to filter: got={}, want=2",
+            args.len()
+        ));
+    }
+
+    match (&args[0], &args[1]) {
+        (Object::Array(arr), Object::Func(params, body, env)) => {
+            let mut new_array: Vec<Object> = Vec::new();
+
+            // We need to make sure the function accepts one argument
+            if params.len() != 1 {
+                return Object::Error(format!(
+                    "filter function expects a function with exactly one parameter, got {} parameters",
+                    params.len()
+                ));
+            }
+
+            for item in arr {
+                // Create a new environment for each function call, with the closure env as outer
+                let mut scoped_env = Env::new_with_outer(Rc::clone(env));
+
+                // Bind the current array item to the function's parameter
+                let Ident(param_name) = params[0].clone();
+                scoped_env.set(param_name, item);
+
+                // Create a new evaluator with this scoped environment
+                let mut evaluator = Evaluator::new(Rc::new(RefCell::new(scoped_env)));
+
+                // Evaluate the function body
+                let result = match evaluator.eval_block_stmt(body.clone()) {
+                    Some(Object::ReturnValue(value)) => *value,
+                    Some(obj) => {
+                        if let Object::Error(_) = obj {
+                            return obj;
+                        }
+                        obj
+                    }
+                    None => Object::Null,
+                };
+
+                // Only include the item if the function returns a truthy value
+                if Evaluator::is_truthy(result) {
+                    new_array.push(item.clone());
+                }
+            }
+
+            Object::Array(new_array)
+        }
+        (Object::Array(_), Object::Builtin(_, _)) => Object::Error(format!(
+            "cannot use builtin functions with filter yet; use a function literal"
+        )),
+        (Object::Array(_), not_func) => Object::Error(format!(
+            "second argument to `filter` must be a function, got {}",
+            not_func
+        )),
+        (not_array, _) => Object::Error(format!(
+            "first argument to `filter` must be an array, got {}",
+            not_array
+        )),
+    }
 }
 
 // TODO