Added assoc, now we can start actually modelling things with our maps!

Author: Tko1

Cargo.toml

@@ -10,3 +10,4 @@ edition = "2018"
 dyn-clone = "1.0"
 nom = "5.1"
 rand = "0.7"
+itertools= "0.9"

src/environment.rs

@@ -76,6 +76,7 @@ impl Environment {
         let do_macro = rust_core::DoMacro {};
         let concat_fn = rust_core::ConcatFn {};
         let print_string_fn = rust_core::PrintStringFn {};
+        let assoc_fn = rust_core::AssocFn {};
         // Hardcoded fns
         let lexical_eval_fn = Value::LexicalEvalFn {};
         // Hardcoded macros
@@ -87,6 +88,7 @@ impl Environment {
         let environment = Rc::new(Environment::new_main_environment());
 
         let eval_fn = rust_core::EvalFn::new(Rc::clone(&environment));
+        let load_file_fn = rust_core::LoadFileFn::new(Rc::clone(&environment));
 
         environment.insert(Symbol::intern("+"), add_fn.to_rc_value());
         environment.insert(Symbol::intern("let"), let_macro.to_rc_value());
@@ -111,8 +113,9 @@ impl Environment {
             Symbol::intern("lexical-eval"),
             lexical_eval_fn.to_rc_value(),
         );
-
+        environment.insert(Symbol::intern("load-file"), load_file_fn.to_rc_value());
         environment.insert(Symbol::intern("nth"), nth_fn.to_rc_value());
+	environment.insert(Symbol::intern("assoc"), assoc_fn.to_rc_value());
         environment.insert(Symbol::intern("concat"), concat_fn.to_rc_value());
         environment.insert(
             Symbol::intern("print-string"),

src/main.rs

@@ -1,5 +1,6 @@
 #[macro_use]
 extern crate nom;
+extern crate itertools;
 
 mod environment;
 mod ifn;
@@ -14,6 +15,7 @@ mod repl;
 mod rust_core;
 mod symbol;
 mod type_tag;
+mod util;
 mod value;
 
 fn main() {

src/rust_core.rs

@@ -8,21 +8,19 @@ use crate::persistent_list::{
     PersistentList::{Cons, Empty},
     ToPersistentList, ToPersistentListIter,
 };
+use crate::persistent_list_map::IPersistentListMap;
 use crate::persistent_vector::{PersistentVector, ToPersistentVectorIter};
+use crate::repl::Repl;
 use crate::symbol::Symbol;
+use crate::type_tag::TypeTag;
 use crate::value::{Evaluable, ToValue};
 
-//
-// This module will hold the core functions and macros that Clojure will
-// hook into; Functions / Macros like "+", "fn*", "let", "cond", etc
-//
-// This is still experimental, and we may instead undo this all and
-// represent fn* and let and the like the same it is done in ClojureJVM,
-// where I believe they are defined flat out in the Compiler class
-//
-// However, even in that case this may stick around to implement basic
-// functions like "+" that usually rely on interop
-//
+use itertools::Itertools;
+
+use crate::util::IsEven;
+
+// 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
 
 #[derive(Debug, Clone)]
 pub struct StrFn {}
@@ -283,3 +281,43 @@ impl IFn for PrintStringFn {
         Value::Nil
     }
 }
+// General assoc fn; however,  currently just implemented
+// for our one map type, PersistentListMap
+#[derive(Debug, Clone)]
+pub struct AssocFn {}
+impl ToValue for AssocFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for AssocFn {
+    fn invoke(&self, args: Vec<&Value>) -> Value {
+        // We don't want even args, because assoc works like
+        // (assoc {} :a 1) ;; 3 args
+        // (assoc {} :a 1 :b 2) ;; 5 args
+        // (assoc {} :a 1 :b 2 :c 3) ;; 7 args ...
+        if args.len() < 3 || args.len().is_even() {
+            return Value::Condition(format!(
+                "Wrong number of arguments given to function (Given: {}, Expected: 3 | 5 | 7 | ..)",
+                args.len()
+            ));
+        }
+
+        if let Value::PersistentListMap(pmap) = args.get(0).unwrap() {
+            let mut retval = pmap.clone();
+            for (key_value, val_value) in args.into_iter().skip(1).tuples() {
+                let key = key_value.to_rc_value();
+                let val = val_value.to_rc_value();
+		println!("key: {:?}, val: {:?}",key,val);
+                retval = pmap.assoc(key, val);
+            }
+            return Value::PersistentListMap(retval);
+        }
+
+        Value::Nil
+    }
+}
+
+        }
+    }
+}

src/util.rs

@@ -0,0 +1,11 @@
+//! Just some nifty little utilities, as all projects accumulate
+
+// Just a little sugar around having to write 'num % 2 == 0'
+pub trait IsEven {
+    fn is_even(&self) -> bool;
+}
+impl IsEven for usize {
+    fn is_even(&self) -> bool {
+        *self % 2 == 0
+    }
+}