Closures remember now

Author: Muhtasim-Rasheed

src/utils/helpers.rs

@@ -23,6 +23,15 @@ pub fn resolve_expression(expr: &Expression, state: &mut State) -> Value {
             }
             Value::Object(object)
         }
+        Expression::Closure { args, body, returns } => {
+            let closure = Function {
+                args: args.clone(),
+                body: body.clone(),
+                returns: *returns.clone(),
+                captured_vars: state.local_vars.to_vec(),
+            };
+            Value::Closure(Box::new(Callable::Function(closure)))
+        }
         Expression::ListMemberAccess { list, index } => {
             let index = resolve_expression(index, state);
             let list = resolve_expression(list, state);

src/utils/language.rs

@@ -1,6 +1,5 @@
 use std::collections::HashMap;
-
-use super::{Function, Value};
+use super::Value;
 
 // ========================= Tokenizer ========================= \\
 
@@ -257,6 +256,11 @@ pub enum Expression {
     Value(Value),
     List(Vec<Expression>),
     Object(HashMap<String, Expression>),
+    Closure {
+        args: Vec<String>,
+        body: Vec<Statement>,
+        returns: Box<Expression>,
+    },
     ListMemberAccess {
         list: Box<Expression>,
         index: Box<Expression>,
@@ -301,6 +305,14 @@ impl Expression {
                     .join(", ");
                 format!("{{ {} }}", obj_str)
             }
+            Expression::Closure { args, returns, .. } => {
+                let args_str = args.join(", ");
+                format!(
+                    "({}) {} {{ ... }}",
+                    args_str,
+                    returns.to_string(),
+                )
+            }
             Expression::ListMemberAccess { list, index } => {
                 format!("{}[{}]", list.to_string(), index.to_string())
             }
@@ -838,13 +850,11 @@ impl Parser {
         }
         let returns = self.parse_binary(0)?;
         let body = self.parse_block()?;
-        Ok(Expression::Value(Value::Closure(Box::new(
-            crate::utils::Callable::Function(Function {
-                args,
-                body,
-                returns,
-            }),
-        ))))
+        Ok(Expression::Closure {
+            args,
+            body,
+            returns: Box::new(returns),
+        })
     }
 
     fn parse_primary(&mut self) -> Result<Expression, String> {

src/utils/sprite/function.rs

@@ -7,6 +7,7 @@ pub struct Function {
     pub args: Vec<String>,
     pub body: Vec<Statement>,
     pub returns: Expression,
+    pub captured_vars: Vec<(String, Value)>,
 }
 
 impl Function {
@@ -23,6 +24,9 @@ impl Function {
         for (i, arg) in self.args.iter().enumerate() {
             new_local_vars.push((arg.clone(), args[i].clone()));
         }
+        for (name, value) in &self.captured_vars {
+            new_local_vars.push((name.clone(), value.clone()));
+        }
         let mut new_state = State {
             start: state.start,
             dt: state.dt,

src/utils/sprite/sprite.rs

@@ -213,6 +213,7 @@ impl Sprite {
                             args: args.clone(),
                             body: body.clone(),
                             returns: returns.clone(),
+                            captured_vars: vec![],
                         }),
                     );
                 }
@@ -267,6 +268,7 @@ impl Sprite {
                                             args: args.clone(),
                                             body: body.clone(),
                                             returns: returns.clone(),
+                                            captured_vars: vec![],
                                         },
                                     );
                                 }