environment now wraps values in Var, and we can inspect these vars with

Tko1 · Tko1 · commit 35b1073e2e8c · 2020-06-09T14:05:25.000-04:00
the var macro
diff --git a/src/clojure/core.clj b/src/clojure/core.clj
@@ -66,3 +66,5 @@
 
 (defn ffirst [x]
   (first (first x)))
+(defmacro var [name]
+  (var-fn* name))
diff --git a/src/environment.rs b/src/environment.rs
@@ -55,6 +55,9 @@ impl EnvironmentVal {
     fn has_namespace(&self, namespace: &Symbol) -> bool {
         self.namespaces.has_namespace(namespace)
     }
+    fn get_var_from_namespace(&self, namespace: &Symbol, sym: &Symbol) -> Rc<Value> {
+        self.namespaces.get_var(namespace, sym)
+    }
     fn get_from_namespace(&self, namespace: &Symbol, sym: &Symbol) -> Rc<Value> {
         self.namespaces.get(namespace, sym)
     }
@@ -216,7 +219,33 @@ impl Environment {
             LocalEnvironment(parent_env, ..) => parent_env.get_main_environment(),
         }
     }
-
+    pub fn get_var(&self, sym: &Symbol) -> Rc<Value> {
+        match self {
+            MainEnvironment(env_val) => {
+                // If we've recieved a qualified symbol like
+                // clojure.core/+
+                if sym.has_ns() {
+                    // Use that namespace
+                    env_val.get_var_from_namespace(&Symbol::intern(&sym.ns), sym)
+                } else {
+                    env_val.get_var_from_namespace(
+                        &env_val.get_current_namespace(),
+                        &Symbol::intern(&sym.name),
+                    )
+                }
+            }
+            LocalEnvironment(parent_env, mappings) => {
+                if sym.ns != "" {
+                    return self.get_main_environment().get(sym);
+                }
+                match mappings.borrow().get(sym) {
+                    Some(val) => Rc::clone(val),
+                    None => parent_env.get(sym),
+                }
+            }
+        }
+    }
+    // @TODO refactor to use ^ 
     // @TODO figure out convention for 'ns' vs 'namespace'
     /// Get closest value "around" us;  try our local environment, then
     /// try our main environment (unless its namespace qualified)
@@ -307,6 +336,8 @@ impl Environment {
         let ns_macro = rust_core::NsMacro::new(Rc::clone(&environment));
         let load_file_fn = rust_core::LoadFileFn::new(Rc::clone(&environment));
         let refer_fn = rust_core::ReferFn::new(Rc::clone(&environment));
+        //let meta_fn = rust_core::MetaFn::new(Rc::clone(&environment));
+        let var_fn = rust_core::special_form::VarFn::new(Rc::clone(&environment));
         // @TODO after we merge this with all the other commits we have,
         //       just change all the `insert`s here to use insert_in_namespace
         //       I prefer explicity and the non-dependence-on-environmental-factors
@@ -325,6 +356,7 @@ impl Environment {
         environment.insert(Symbol::intern("fn"), fn_macro.to_rc_value());
         environment.insert(Symbol::intern("defmacro"), defmacro_macro.to_rc_value());
         environment.insert(Symbol::intern("eval"), eval_fn.to_rc_value());
+        environment.insert(Symbol::intern("var-fn*"), var_fn.to_rc_value());
 
         // Thread namespace
         environment.insert_into_namespace(
@@ -428,20 +460,13 @@ impl Environment {
             split_fn.to_rc_value(),
         );
 
-        environment.insert(Symbol::intern("+"), add_fn.to_rc_value());
-        environment.insert(Symbol::intern("let"), let_macro.to_rc_value());
-        environment.insert(Symbol::intern("str"), str_fn.to_rc_value());
-        environment.insert(Symbol::intern("map"), map_fn.to_rc_value());
 
         environment.insert(Symbol::intern("quote"), quote_macro.to_rc_value());
         environment.insert(Symbol::intern("do-fn*"), do_fn.to_rc_value());
         environment.insert(Symbol::intern("do"), do_macro.to_rc_value());
         environment.insert(Symbol::intern("def"), def_macro.to_rc_value());
-        environment.insert(Symbol::intern("fn"), fn_macro.to_rc_value());
         environment.insert(Symbol::intern("if"), if_macro.to_rc_value());
-        environment.insert(Symbol::intern("defmacro"), defmacro_macro.to_rc_value());
         environment.insert(Symbol::intern("ns"), ns_macro.to_rc_value());
-        environment.insert(Symbol::intern("eval"), eval_fn.to_rc_value());
         environment.insert(
             Symbol::intern("lexical-eval"),
             lexical_eval_fn.to_rc_value(),
diff --git a/src/main.rs b/src/main.rs
@@ -10,6 +10,8 @@ mod persistent_list;
 mod protocol;
 #[macro_use]
 mod symbol;
+#[macro_use]
+mod var;
 mod clojure_std;
 mod clojure_string;
 mod environment;
@@ -19,6 +21,7 @@ mod iterable;
 mod keyword;
 mod lambda;
 mod maps;
+mod meta;
 mod namespace;
 mod persistent_vector;
 mod reader;
@@ -28,7 +31,6 @@ mod type_tag;
 mod user_action;
 mod util;
 mod value;
-
 mod protocols;
 mod traits;
 fn main() {
diff --git a/src/namespace.rs b/src/namespace.rs
@@ -1,5 +1,7 @@
+use crate::persistent_list_map::PersistentListMap;
 use crate::symbol::Symbol;
-use crate::value::Value;
+use crate::var::Var;
+use crate::value::{ToValue, Value};
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::rc::Rc;
@@ -126,12 +128,18 @@ impl Default for Refers {
 #[derive(Debug, Clone)]
 pub struct Namespace {
     pub name: Symbol,
-    mappings: RefCell<HashMap<Symbol, Rc<Value>>>,
     pub refers: RefCell<Refers>,
+    // @TODO decide to make Var a Rc<Var> ?
+    // On one hand,  its internals (except its ns and name) are Rcs, so cloning is still
+    // cloning a reference
+    //
+    // On the other hand,  the Var itself, regardless, lives in one spot and is referenced by many
+    // This explicitly shows its a reference
+    mappings: RefCell<HashMap<Symbol, Var>>,
 }
 
 impl Namespace {
-    fn new(name: &Symbol, mappings: HashMap<Symbol, Rc<Value>>, refers: Refers) -> Namespace {
+    fn new(name: &Symbol, mappings: HashMap<Symbol, Var>, refers: Refers) -> Namespace {
         Namespace {
             name: name.unqualified(),
             mappings: RefCell::new(mappings),
@@ -155,20 +163,47 @@ impl Namespace {
             .replace_with(|refers| refers.add_referred_namespaces(namespaces));
     }
 
+    //
+    fn contains_key(&self,sym: &Symbol) -> bool {
+        self.mappings.borrow_mut().contains_key(sym)
+    }
     pub fn insert(&self, sym: &Symbol, val: Rc<Value>) {
-        self.mappings.borrow_mut().insert(sym.unqualified(), val);
+        if !self.contains_key(sym) {
+            let var = var!(&self.name.name,&sym.name);
+            var.bind_root(val);
+            var.set_meta(sym.meta());
+            self.mappings
+                .borrow_mut()
+                .insert(sym.unqualified(), var);
+        } else {
+            let mappings = self.mappings.borrow_mut();
+            let var = mappings
+                .get(&sym.unqualified())
+                .unwrap();
+
+            var.bind_root(val);
+            var.set_meta(sym.meta());
+        }
+    }
+
+    pub fn get_var(&self, sym: &Symbol) -> Rc<Value> {
+        match self.mappings.borrow_mut().get(&sym.unqualified()).map(|var| var.clone()) {
+            Some(var) => Rc::new(Value::Var(var)),
+            None => Rc::new(Value::Condition(format!("Undefined symbol {}", sym.name))),
+        }
     }
 
     pub fn try_get(&self, sym: &Symbol) -> Option<Rc<Value>> {
         match self.mappings.borrow_mut().get(&sym.unqualified()) {
-            Some(val) => Some(Rc::clone(val)),
+            Some(var) => Some(var.deref()),
             None => None,
         }
     }
+
     pub fn get(&self, sym: &Symbol) -> Rc<Value> {
         match self.try_get(sym) {
             Some(val) => val,
-            None => Rc::new(Value::Condition(format!("1 Undefined symbol {}", sym.name))),
+            None => Rc::new(Value::Condition(format!("Undefined symbol {}", sym.name))),
         }
     }
 }
@@ -260,7 +295,28 @@ impl Namespaces {
             }
         }
     }
+    // TODO write this similar to try_get, and rewrite try_get in terms of this 
+    pub fn get_var(&self, namespace_sym: &Symbol, sym: &Symbol) -> Rc<Value> {
+        // When storing / retrieving from namespaces, we want
+        // namespace_sym unqualified keys
+        let mut namespace_sym = namespace_sym.unqualified();
+
+        // @TODO just make it an Optional<String>
+        // If our sym is namespace qualified,  use that as our namespace
+        if sym.has_ns() {
+            namespace_sym = Symbol::intern(&sym.ns);
+        }
+
+        let sym = sym.unqualified();
+        let namespaces = self.0.borrow();
+        let namespace = namespaces.get(&namespace_sym);
 
+        match namespace {
+            Some(namespace) => namespace.get_var(&sym),
+            // @TODO should this be a condition or nil?
+            _ => Rc::new(Value::Condition(format!("Undefined symbol {}", sym.name))),
+        }
+    }
     /// Like get, but slightly lower level; returns a None on failure rather than a
     /// Value::Condition. See docs for get
     pub fn try_get(&self, namespace_sym: &Symbol, sym: &Symbol) -> Option<Rc<Value>> {
@@ -313,11 +369,11 @@ impl Namespaces {
                 //  { 'clojure.core ['a 'b 'c] ,
                 //    'clojure.string ['x 'y 'z]}
                 //  referred_namespace_sym: Symbol::intern("clojure.core"),
-                //  referred_syms:          vec![Symbol::intern("x"), .. Symbol::intern("z")]
+                //  referred_syms:          vec![Symbol::intern("a"), .. Symbol::intern("c")]
                 for (referred_namespace_sym, referred_syms) in referred_syms_map.iter() {
                     // Ex: (if we're trying to get, say,  '+)
                     //     Do we even refer a '+ from this namespace?
-                    //     'clojure.string ['x 'y 'z] <-- no
+                    //     'clojure.core ['a 'b 'c] <-- no
                     //     Continue then
                     if !referred_syms.contains(&sym) {
                         continue;
@@ -710,12 +766,12 @@ mod tests {
             namespace.insert(&Symbol::intern("a"), Rc::new(Value::Nil));
             namespace.insert(&Symbol::intern_with_ns("ns", "b"), Rc::new(Value::Nil));
             match &*namespace.get(&Symbol::intern("a")) {
-                Value::Condition(_) => panic!("We are unable to get a symbol we've put into our namespace created with from_sym()"),
+                Value::Condition(_) => panic!("We are unable to get a symbol (a) we've put into our namespace created with from_sym()"),
                 _ => {}
             }
 
             match &*namespace.get(&Symbol::intern("b")) {
-                Value::Condition(_) => panic!("We are unable to get a symbol we've put into our namespace created with from_sym()"),
+                Value::Condition(_) => panic!("We are unable to get a symbol (ns/b) we've put into our namespace created with from_sym()"),
                 _ => {}
             }
 
diff --git a/src/protocol.rs b/src/protocol.rs
@@ -78,7 +78,7 @@ impl ProtocolCastable for Rc<Value> {
 macro_rules! define_protocol {
     // define_protocol!(Protocol = A | B)
     ($protocol:ident = $($variant:ident) |*) => {
-        #[derive(Debug, Clone)]
+        #[derive(Hash,PartialEq,Eq,Debug, Clone)]
         pub struct $protocol {
             value: Rc<Value>
         }
diff --git a/src/protocols/imeta.rs b/src/protocols/imeta.rs
@@ -9,7 +9,8 @@ use crate::value::Value;
 use std::rc::Rc;
 
 define_protocol!(
-    IMeta = PersistentList     |
+    IMeta = Var                | // <-- where all the magic happens
+            PersistentList     |
             PersistentVector   |
             PersistentListMap  |
             Symbol //             |
@@ -30,6 +31,9 @@ impl traits::IMeta for IMeta {
             Value::Symbol(val) => {
                 val.meta()
             }
+            Value::Var(var) => {
+                var.meta()
+            }
             _ => panic!("protocols::IMeta was wrapping an invalid type {} when calling meta()",self.value.type_tag())
             // Value::IFn(val) => {
             //     val.with_meta(meta)
diff --git a/src/protocols/ipersistent_map.rs b/src/protocols/ipersistent_map.rs
@@ -3,7 +3,7 @@ use std::rc::Rc;
 use crate::persistent_list_map;
 use crate::protocol::ProtocolCastable;
 
-define_protocol!(IPersistentMap,PersistentListMap);
+define_protocol!(IPersistentMap = PersistentListMap);
 
 impl persistent_list_map::IPersistentMap for IPersistentMap {
     fn get(&self, key: &Rc<Value>) -> Rc<Value> {
diff --git a/src/rust_core.rs b/src/rust_core.rs
@@ -1,6 +1,10 @@
 // This module will hold core function and macro primitives that aren't special cases
 // (like the quote macro, or let), and can't be implemented in clojure itself
 
+// special forms
+pub(crate) mod special_form;
+pub use self::special_form::*;
+
 // language core functions
 pub(crate) mod eval;
 pub use self::eval::*;
diff --git a/src/rust_core/special_form.rs b/src/rust_core/special_form.rs
@@ -0,0 +1,35 @@
+/*
+
+Clojure Special Forms
+
+(pprint (keys (. clojure.lang.Compiler specials)))
+
+TODO: &
+TODO: monitor-exit
+TODO: case*
+TODO: try
+TODO: reify*
+TODO: finally
+TODO: loop*
+TODO: do
+TODO: letfn*
+TODO: if
+TODO: clojure.core/import*
+TODO: new
+TODO: deftype*
+TODO: let*
+TODO: fn*
+TODO: recur
+TODO: set!
+TODO: .
+* var
+TODO: quote
+TODO: catch
+TODO: throw
+TODO: monitor-enter
+TODO: def
+
+*/
+
+pub(crate) mod var;
+pub use self::var::*;
diff --git a/src/rust_core/special_form/var.rs b/src/rust_core/special_form/var.rs
@@ -0,0 +1,43 @@
+use crate::environment::Environment;
+use crate::error_message;
+use crate::ifn::IFn;
+use crate::type_tag::TypeTag;
+use crate::value::{ToValue, Value};
+use std::rc::Rc;
+
+/// Returns var for symbol
+/// example (var println)
+#[derive(Debug, Clone)]
+pub struct VarFn {
+    enclosing_environment: Rc<Environment>,
+}
+impl VarFn {
+    pub fn new(enclosing_environment: Rc<Environment>) -> VarFn {
+        VarFn {
+            enclosing_environment,
+        }
+    }
+}
+impl ToValue for VarFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for VarFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        if args.len() != 1 {
+            return error_message::wrong_arg_count(1, args.len());
+        }
+
+        match args.get(0).unwrap().to_value() {
+            Value::Symbol(s) => match &*self.enclosing_environment.get_var(&s) {
+                var @ Value::Var(_) => var.clone(),
+                error @ Value::Condition(_) => error.clone(),
+                _ => panic!("environment.get_var didn't return Var or Condition in var special form")
+            },
+            _ => {
+                error_message::type_mismatch(TypeTag::Symbol, args.get(0).unwrap())
+            }
+        }
+    }
+}
diff --git a/src/symbol.rs b/src/symbol.rs
diff --git a/src/type_tag.rs b/src/type_tag.rs
diff --git a/src/value.rs b/src/value.rs
diff --git a/src/var.rs b/src/var.rs

Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ impl ProtocolCastable for Rc<Value> {`
`78`	`78`	`macro_rules! define_protocol {`
`79`	`79`	`// define_protocol!(Protocol = A \| B)`
`80`	`80`	`($protocol:ident = $($variant:ident) \|*) => {`
`81`		`- #[derive(Debug, Clone)]`
	`81`	`+ #[derive(Hash,PartialEq,Eq,Debug, Clone)]`
`82`	`82`	`pub struct $protocol {`
`83`	`83`	`value: Rc<Value>`
`84`	`84`	`}`