src/main.rs

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

src/process.rs

@@ -1,14 +1,12 @@
 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>,
@@ -30,13 +28,11 @@ 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> {
@@ -105,7 +101,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) => {
@@ -213,7 +209,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 self.match_pattern(&patt.0, value).is_some() {
+                if let Some(_) = self.match_pattern(&patt.0, value) {
                     let pass_guard = match guard.as_ref() {
                         None => true,
                         Some((ast, _)) => {
@@ -236,7 +232,7 @@ impl<'src> Process<'src> {
                     return res;
                 }
             }
-            Err(LErr::new("no match".to_string()))
+            Err(LErr::new(format!("no match")))
         }
     }
 
@@ -259,17 +255,11 @@ impl<'src> Process<'src> {
             }
             (Fn(f), Tuple(args)) => {
                 let args = Tuple(args);
-                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
+                self.match_clauses(&args, f.body)
             }
-            // TODO: partially applied functions shnould work! In #15
             (Fn(_f), Args(_args)) => todo!(),
             (_, Keyword(_)) => Ok(Nil),
-            (_, Args(_)) => Err(LErr::new("you may only call a function".to_string())),
+            (_, Args(_)) => Err(LErr::new(format!("you may only call a function"))),
             (Base(f), Tuple(args)) => match f {
                 BaseFn::Nullary(f) => {
                     let num_args = args.len();
@@ -344,7 +334,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);
@@ -370,9 +360,9 @@ impl<'src> Process<'src> {
                         match to_splat {
                             Value::List(list) => vect.append(list),
                             _ => {
-                                return Err(LErr::new(
-                                    "only lists may be splatted into lists".to_string(),
-                                ))
+                                return Err(LErr::new(format!(
+                                    "only lists may be splatted into lists"
+                                )))
                             }
                         }
                     } else {
@@ -402,7 +392,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("no match".to_string())),
+                    None => Err(LErr::new(format!("no match"))),
                 };
                 self.ast = parent;
                 result
@@ -439,9 +429,7 @@ impl<'src> Process<'src> {
                             self.ast = term;
                             let resolved = self.eval()?;
                             let Value::Dict(to_splat) = resolved else {
-                                return Err(LErr::new(
-                                    "cannot splat non-dict into dict".to_string(),
-                                ));
+                                return Err(LErr::new(format!("cannot splat non-dict into dict")));
                             };
                             dict = to_splat.union(dict);
                         }
@@ -489,7 +477,7 @@ impl<'src> Process<'src> {
                         return result;
                     };
                 }
-                Err(LErr::new("no match".to_string()))
+                Err(LErr::new(format!("no match")))
             }
             Match(value, clauses) => {
                 let parent = self.ast;
@@ -501,23 +489,10 @@ 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)
@@ -533,7 +508,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("`repeat` may only take numbers".to_string())),
+                    _ => return Err(LErr::new(format!("repeat may only take numbers"))),
                 };
                 self.ast = &body.0;
                 for _ in 0..times_num {

src/value.rs

@@ -12,7 +12,6 @@ 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)]