get closing working?

src/main.rs

@@ -87,14 +87,20 @@ pub fn prelude<'src>() -> Process<'src> {
         panic!();
     }
 
-    let p_ast = Box::leak(Box::new(p_ast.unwrap().0));
+    let (p_ast, p_span) = Box::leak(Box::new(p_ast.unwrap()));
     let base_pkg = base();
 
+    let base_names = base_pkg.iter().map(|binding| binding.0.clone()).collect();
+
+    let mut v6or = Validator::new(p_ast, *p_span, &base_names);
+    v6or.validate();
+
     let mut base_ctx = Process::<'src> {
         locals: vec![],
         ast: p_ast,
         prelude: base_pkg,
-        // prelude_ast: &Ast::Nil,
+        args: Value::Nil,
+        fn_info: v6or.fn_info,
     };
 
     let prelude = base_ctx.eval();
@@ -122,7 +128,8 @@ pub fn prelude<'src>() -> Process<'src> {
         locals: vec![],
         ast: &Ast::Nil,
         prelude: p_ctx,
-        // prelude_ast: p_ast,
+        args: Value::Nil,
+        fn_info: base_ctx.fn_info,
     }
 }
 
@@ -147,16 +154,17 @@ pub fn run(src: &'static str) {
 
     let dummy_prelude = vec![];
 
-    let mut v6or = validator::Validator::new(&ast, span, &dummy_prelude);
+    let mut v6or = Validator::new(&ast, span, &dummy_prelude);
 
     v6or.validate();
 
-    dbg!(v6or);
+    dbg!(&v6or);
 
-    let mut ctx = prelude();
+    let mut proc = prelude();
-    ctx.ast = &ast;
+    proc.ast = &ast;
+    proc.fn_info.extend(&mut v6or.fn_info.into_iter());
 
-    let result = ctx.eval();
+    let result = proc.eval();
 
     match result {
         Ok(result) => println!("{}", result),
@@ -166,15 +174,8 @@ pub fn run(src: &'static str) {
 
 pub fn main() {
     let src = "
-fn bar
+let bar = :bar
-
+fn foo () -> bar
-fn foo {
-    () -> bar(:foo)
-    (:bar) -> :done
-}
-
-fn bar (_) -> :bar
-
 foo ()
     ";
     run(src);

src/process.rs

@@ -1,12 +1,14 @@
 use crate::base::*;
 use crate::parser::*;
 use crate::spans::*;
+use crate::validator::FnInfo;
 use crate::value::Value;
 use imbl::HashMap;
 use imbl::Vector;
 use std::cell::RefCell;
 use std::rc::Rc;
 
+#[derive(Debug)]
 pub struct LErr {
     pub msg: String,
     pub trace: Vec<String>,
@@ -28,11 +30,13 @@ impl LErr {
 
 type LResult<'src> = Result<Value<'src>, LErr>;
 
+#[derive(Debug)]
 pub struct Process<'src> {
     pub locals: Vec<(String, Value<'src>)>,
     pub prelude: Vec<(String, Value<'src>)>,
-    // pub prelude_ast: &'src Ast,
     pub ast: &'src Ast,
+    pub args: Value<'src>,
+    pub fn_info: std::collections::HashMap<*const Ast, FnInfo>,
 }
 
 impl<'src> Process<'src> {
@@ -101,7 +105,7 @@ impl<'src> Process<'src> {
                 }
             }
             (WordPattern(w), val) => {
-                self.bind(w.to_string(), &val);
+                self.bind(w.to_string(), val);
                 Some(self)
             }
             (AsPattern(word, type_str), value) => {
@@ -209,7 +213,7 @@ impl<'src> Process<'src> {
             let to = self.locals.len();
             let mut clauses = clauses.iter();
             while let Some((Ast::MatchClause(patt, guard, body), _)) = clauses.next() {
-                if let Some(_) = self.match_pattern(&patt.0, value) {
+                if self.match_pattern(&patt.0, value).is_some() {
                     let pass_guard = match guard.as_ref() {
                         None => true,
                         Some((ast, _)) => {
@@ -232,7 +236,7 @@ impl<'src> Process<'src> {
                     return res;
                 }
             }
-            Err(LErr::new(format!("no match")))
+            Err(LErr::new("no match".to_string()))
         }
     }
 
@@ -255,11 +259,17 @@ impl<'src> Process<'src> {
             }
             (Fn(f), Tuple(args)) => {
                 let args = Tuple(args);
-                self.match_clauses(&args, f.body)
+                let to = self.locals.len();
+                let mut enclosing = f.enclosing.clone();
+                self.locals.append(&mut enclosing);
+                let result = self.match_clauses(&args, f.body);
+                self.locals.truncate(to);
+                result
             }
+            // TODO: partially applied functions shnould work! In #15
             (Fn(_f), Args(_args)) => todo!(),
             (_, Keyword(_)) => Ok(Nil),
-            (_, Args(_)) => Err(LErr::new(format!("you may only call a function"))),
+            (_, Args(_)) => Err(LErr::new("you may only call a function".to_string())),
             (Base(f), Tuple(args)) => match f {
                 BaseFn::Nullary(f) => {
                     let num_args = args.len();
@@ -334,7 +344,7 @@ impl<'src> Process<'src> {
                 let to = self.locals.len();
                 let mut result = Value::Nil;
                 for (expr, _) in exprs {
-                    self.ast = &expr;
+                    self.ast = expr;
                     result = self.eval()?;
                 }
                 self.pop_to(to);
@@ -360,9 +370,9 @@ impl<'src> Process<'src> {
                         match to_splat {
                             Value::List(list) => vect.append(list),
                             _ => {
-                                return Err(LErr::new(format!(
+                                return Err(LErr::new(
-                                    "only lists may be splatted into lists"
+                                    "only lists may be splatted into lists".to_string(),
-                                )))
+                                ))
                             }
                         }
                     } else {
@@ -392,7 +402,7 @@ impl<'src> Process<'src> {
                 let val = self.eval()?;
                 let result = match self.match_pattern(&patt.0, &val) {
                     Some(_) => Ok(val),
-                    None => Err(LErr::new(format!("no match"))),
+                    None => Err(LErr::new("no match".to_string())),
                 };
                 self.ast = parent;
                 result
@@ -429,7 +439,9 @@ impl<'src> Process<'src> {
                             self.ast = term;
                             let resolved = self.eval()?;
                             let Value::Dict(to_splat) = resolved else {
-                                return Err(LErr::new(format!("cannot splat non-dict into dict")));
+                                return Err(LErr::new(
+                                    "cannot splat non-dict into dict".to_string(),
+                                ));
                             };
                             dict = to_splat.union(dict);
                         }
@@ -477,7 +489,7 @@ impl<'src> Process<'src> {
                         return result;
                     };
                 }
-                Err(LErr::new(format!("no match")))
+                Err(LErr::new("no match".to_string()))
             }
             Match(value, clauses) => {
                 let parent = self.ast;
@@ -489,10 +501,23 @@ impl<'src> Process<'src> {
             }
             Fn(name, clauses, doc) => {
                 let doc = doc.map(|s| s.to_string());
+                let ptr: *const Ast = root;
+                dbg!(&root);
+                dbg!(&ptr);
+                dbg!(&self.fn_info);
+                let info = self.fn_info.get(&ptr).unwrap();
+                let FnInfo::Defined(_, enclosing) = info else {
+                    unreachable!()
+                };
+                let enclosing = enclosing
+                    .iter()
+                    .map(|name| (name.clone(), self.resolve(name).unwrap().clone()))
+                    .collect();
                 let the_fn = Value::Fn::<'src>(Rc::new(crate::value::Fn::<'src> {
                     name: name.to_string(),
                     body: clauses,
                     doc,
+                    enclosing,
                 }));
                 self.bind(name.to_string(), &the_fn);
                 Ok(the_fn)
@@ -508,7 +533,7 @@ impl<'src> Process<'src> {
                 self.ast = &times.0;
                 let times_num = match self.eval() {
                     Ok(Value::Number(n)) => n as usize,
-                    _ => return Err(LErr::new(format!("repeat may only take numbers"))),
+                    _ => return Err(LErr::new("`repeat` may only take numbers".to_string())),
                 };
                 self.ast = &body.0;
                 for _ in 0..times_num {

src/value.rs

@@ -12,6 +12,7 @@ pub struct Fn<'src> {
     pub name: String,
     pub body: &'src Vec<Spanned<Ast>>,
     pub doc: Option<String>,
+    pub enclosing: Vec<(String, Value<'src>)>,
 }
 
 #[derive(Debug, Dissectible)]