Merge branch 'milestone/develop_core'

Author: Tko1

.gitignore

@@ -63,5 +63,4 @@ Session.vim
 tags
 
 .idea
-
 Cargo.lock

src/environment.rs

@@ -208,6 +208,9 @@ impl Environment {
         let thread_sleep_fn = clojure_std::thread::SleepFn {};
         let nanotime_fn = clojure_std::time::NanoTimeFn {};
 
+	      let get_fn = rust_core::GetFn {};
+        let map_fn = rust_core::MapFn {};
+	
         // Hardcoded fns
         let lexical_eval_fn = Value::LexicalEvalFn {};
         // Hardcoded macros
@@ -216,15 +219,17 @@ impl Environment {
         let def_macro = Value::DefMacro {};
         let fn_macro = Value::FnMacro {};
         let defmacro_macro = Value::DefmacroMacro {};
+	      let if_macro = Value::IfMacro {};
         let environment = Rc::new(Environment::new_main_environment());
 
-	let eval_fn = rust_core::EvalFn::new(Rc::clone(&environment));
-	let ns_macro = rust_core::NsMacro::new(Rc::clone(&environment));
+	      let eval_fn = rust_core::EvalFn::new(Rc::clone(&environment));
+	      let ns_macro = rust_core::NsMacro::new(Rc::clone(&environment));
+        let load_file_fn = rust_core::LoadFileFn::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
+	      environment.change_namespace(Symbol::intern("clojure.core"));
 
-	// @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
-	environment.change_namespace(Symbol::intern("clojure.core"));
 
         environment.insert(Symbol::intern("+"), add_fn.to_rc_value());
         environment.insert(Symbol::intern("-"), subtract_fn.to_rc_value());
@@ -258,20 +263,25 @@ impl Environment {
         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(),
         );
+	      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("assoc"), assoc_fn.to_rc_value());
+	      environment.insert(Symbol::intern("get"), get_fn.to_rc_value());
         environment.insert(Symbol::intern("concat"), concat_fn.to_rc_value());
         environment.insert(
             Symbol::intern("print-string"),

src/iterable.rs

@@ -0,0 +1,78 @@
+use crate::protocol::Protocol;
+use crate::value::Value;
+use crate::value::ToValue;
+use crate::persistent_list_map::PersistentListMapIter;
+use crate::persistent_vector::PersistentVectorIter;
+use crate::persistent_list::PersistentListIter;
+use crate::persistent_list_map::ToPersistentListMapIter;
+use crate::persistent_vector::ToPersistentVectorIter;
+use crate::persistent_list::ToPersistentListIter;
+use crate::persistent_vector::ToPersistentVector;
+use std::rc::Rc;
+use std::iter::FromIterator;
+
+//
+// This Protocol lives inside of Clojure RS
+//
+#[derive(Debug, Clone)] 
+pub struct Iterable {
+    value: Rc<Value>
+}
+impl Protocol for Iterable {
+    fn try_as_protocol(val: &Rc<Value>) -> Option<Self> {
+        match &**val {
+            Value::PersistentList(_) =>
+                Some(Iterable { value: Rc::clone(val)}),
+            Value::PersistentVector(_) =>
+                Some(Iterable { value: Rc::clone(val)}),
+            Value::PersistentListMap(_) =>
+                Some(Iterable { value: Rc::clone(val)}),
+            _ =>
+                None
+        }
+    }
+    fn try_unwrap(&self) -> Option<Rc<Value>> {
+        match &*self.value {
+            Value::PersistentList(_) => Some(Rc::clone(&self.value)),
+            Value::PersistentVector(_) => Some(Rc::clone(&self.value)),
+            Value::PersistentListMap(_) => Some(Rc::clone(&self.value)),
+            _ => None 
+        }
+    } 
+}
+pub enum IterableIter {
+    PersistentList(PersistentListIter),
+    PersistentVector(PersistentVectorIter),
+    PersistentListMap(PersistentListMapIter),
+}
+impl Iterator for IterableIter {
+    type Item = Rc<Value>;
+    fn next(&mut self) -> Option<Self::Item> {
+        match self {
+            IterableIter::PersistentList(plist_giter) => plist_giter.next(),
+            IterableIter::PersistentVector(pvector_iter) => pvector_iter.next(),
+            IterableIter::PersistentListMap(plist_map_iter) => {
+                let maybe_map_entry = plist_map_iter.next();
+                if let Some(map_entry) = maybe_map_entry {
+                    // In Clojure: [key val]
+                    return Some(vec![map_entry.key.clone(), map_entry.val.clone()].into_vector().to_rc_value());
+                }
+                None 
+            }
+        }
+    }
+}
+impl Iterable {
+    pub fn iter(&self) -> IterableIter
+    {
+        match &*self.value  {
+            Value::PersistentList(plist) => IterableIter::PersistentList(Rc::new(plist.clone()).iter()),
+            Value::PersistentVector(pvector) => IterableIter::PersistentVector(Rc::new(pvector.clone()).iter()),
+            Value::PersistentListMap(pmap) => IterableIter::PersistentListMap(Rc::new(pmap.clone()).iter()),
+            // We are ok panicking in this case because an invariant on the type is the assumption
+            // that we only have an Iterable if we were able to convert 
+            _ => panic!("Called Iterable iter on non-iterable")
+        }
+        
+    }
+}

src/main.rs

@@ -20,6 +20,8 @@ mod symbol;
 mod type_tag;
 mod util;
 mod value;
+mod protocol;
+mod iterable;
 
 fn main() {
     //

src/persistent_list_map.rs

@@ -30,11 +30,11 @@ pub enum PersistentListMap {
 // Again, only using strange IBlah convention to reflect the Clojure base
 // @TODO really though .. just rethink this
 /// A PersistentListMap.
-pub trait IPersistentListMap {
+pub trait IPersistentMap {
     fn get(&self, key: &Rc<Value>) -> Rc<Value>;
     fn assoc(&self, key: Rc<Value>, value: Rc<Value>) -> Self;
 }
-impl IPersistentListMap for PersistentListMap {
+impl IPersistentMap for PersistentListMap {
     // @TODO make fn of ILookup
     fn get(&self, key: &Rc<Value>) -> Rc<Value> {
         match self {
@@ -52,7 +52,7 @@ impl IPersistentListMap for PersistentListMap {
     }
 }
 
-impl IPersistentListMap for Rc<PersistentListMap> {
+impl IPersistentMap for Rc<PersistentListMap> {
     // @TODO make fn of ILookup
     fn get(&self, key: &Rc<Value>) -> Rc<Value> {
         match &**self {

src/protocol.rs

@@ -0,0 +1,41 @@
+use crate::value::Value;
+use std::rc::Rc;
+
+// @TODO should we just exclusively call them protocols as
+//       we've been doing (deciding that Clojure without the host
+//       has Protocols as its natural abstraction for interfaces)
+//       or should interfaces, as an abstraction, exist (and perhaps
+//       be used by Protocols even?)
+/// A type that implements Protocol is one that has a pseudo downcasting of
+///
+/// value.as::<ISeq>()
+///
+/// Where ISeq would implement Protocol
+///
+/// Then you can call functions on this ISeq, if you got one back, to forward
+/// functions to the Value inside, and unwrap() it to get your Value back when
+/// you're done
+pub trait Protocol: Sized {
+    fn try_as_protocol(val: &Rc<Value>) -> Option<Self>; // where Self:Sized;
+    /// Panics if your Value isn't an instance of Protocol 
+    fn as_protocol(val: &Rc<Value>) -> Self {
+        Self::try_as_protocol(val).unwrap()
+    }
+    fn try_unwrap(&self) -> Option<Rc<Value>>;
+    /// Panics if your Value isn't an instance of Protocol 
+    fn unwrap(&self) -> Rc<Value>{
+        self.try_unwrap().unwrap()  
+    }
+}
+pub trait ProtocolCastable {
+    fn try_as_protocol<T: Protocol>(&self) -> Option<T>;
+    fn as_protocol<T: Protocol>(&self) -> T; 
+}
+impl ProtocolCastable for Rc<Value>{
+    fn try_as_protocol<T: Protocol>(&self) -> Option<T> {
+        T::try_as_protocol(self)
+    }
+    fn as_protocol<T: Protocol>(&self) -> T {
+        T::as_protocol(self)
+    }
+}

src/reader.rs

@@ -341,6 +341,18 @@ pub fn try_read_symbol(input: &str) -> IResult<&str, Value> {
     to_value_parser(symbol_parser)(input)
 }
 
+
+/// Tries to parse a &str that says 'nil' into Value::Nil
+/// Example Successes:
+///    nil => Value::Nil
+pub fn try_read_nil(input: &str) -> IResult<&str, Value> {
+    named!(nil<&str, &str>, preceded!(consume_clojure_whitespaces_parser, tag!("nil")));
+
+    let (rest_input, _) = nil(input)?;
+    
+    Ok((rest_input,Value::Nil))
+}
+
 // @TODO allow escaped strings
 /// Tries to parse &str into Value::String
 /// Example Successes:
@@ -454,6 +466,7 @@ pub fn try_read(input: &str) -> IResult<&str, Value> {
         consume_clojure_whitespaces_parser,
         alt((
             try_read_quoted,
+	          try_read_nil,
             try_read_map,
             try_read_string,
             try_read_f64,

src/rust_core.rs

@@ -1,3 +1,29 @@
+use crate::value::Value;
+use std::rc::Rc;
+
+use crate::environment::Environment;
+use crate::ifn::IFn;
+use crate::persistent_list::{
+    PersistentList,
+    PersistentList::{Cons, Empty},
+    ToPersistentList, ToPersistentListIter,
+};
+use crate::persistent_list_map::IPersistentMap;
+use crate::persistent_vector::{PersistentVector, ToPersistentVectorIter};
+use crate::symbol::Symbol;
+use crate::keyword::Keyword;
+use crate::type_tag::TypeTag;
+use crate::value::{Evaluable, ToValue};
+use crate::repl::Repl;
+use crate::error_message;
+use crate::util::IsEven;
+
+use itertools::Itertools;
+
+use crate::protocol::ProtocolCastable;
+use crate::protocol::Protocol; 
+use crate::iterable::Iterable;
+
 // 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
 
@@ -42,8 +68,12 @@ pub(crate) mod concat;
 pub use self::concat::*;
 pub(crate) mod assoc;
 pub use self::assoc::*;
+pub(crate) mod get;
+pub use self::get::*;
+pub(crate) mod map;
+pub use self::map::*;
 
-// input and output
+// input and outputy
 pub(crate) mod print_string;
 pub use self::print_string::*;
 pub(crate) mod string_print;
@@ -52,3 +82,8 @@ pub use self::string_print::*;
 // other
 pub(crate) mod slurp;
 pub use self::slurp::*;
+
+pub(crate) mod load_file;
+pub use self::load_file::*;
+
+

src/rust_core/_divide_.rs

@@ -16,7 +16,7 @@ impl ToValue for DivideFn {
 impl IFn for DivideFn {
     fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
         match args.len() {
-            0 => error_message::wrong_arg_count(1,args.len()),
+            0 => error_message::zero_arg_count(args.len()),
             1 => {
                 let val = args.get(0).unwrap().to_value();
                 match val {

src/rust_core/assoc.rs

@@ -3,7 +3,7 @@ use crate::value::{Value, ToValue};
 use std::rc::Rc;
 use crate::util::IsEven;
 use itertools::Itertools;
-use crate::persistent_list_map::IPersistentListMap;
+use crate::persistent_list_map::IPersistentMap;
 
 /// (assoc map key val & kvs)
 ///