Added Protocols (from Rust's perspective at least) and used an Iterable Protocol

to implement map

Author: Tko1

src/environment.rs

@@ -77,7 +77,8 @@ impl Environment {
         let concat_fn = rust_core::ConcatFn {};
         let print_string_fn = rust_core::PrintStringFn {};
         let assoc_fn = rust_core::AssocFn {};
-	let get_fn = rust_core::GetFn {};
+	      let get_fn = rust_core::GetFn {};
+        let map_fn = rust_core::MapFn {};
 
         // Hardcoded fns
         let lexical_eval_fn = Value::LexicalEvalFn {};
@@ -87,10 +88,10 @@ impl Environment {
         let def_macro = Value::DefMacro {};
         let fn_macro = Value::FnMacro {};
         let defmacro_macro = Value::DefmacroMacro {};
-	let if_macro = Value::IfMacro {};
+	      let if_macro = Value::IfMacro {};
         let environment = Rc::new(Environment::new_main_environment());
-	
-	let load_file_fn = rust_core::LoadFileFn::new(Rc::clone(&environment));
+	      
+	      let load_file_fn = rust_core::LoadFileFn::new(Rc::clone(&environment));
         let eval_fn = rust_core::EvalFn::new(Rc::clone(&environment));
 
         environment.insert(Symbol::intern("+"), add_fn.to_rc_value());
@@ -105,22 +106,24 @@ 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("if"), if_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("lexical-eval"),
             lexical_eval_fn.to_rc_value(),
         );
-	environment.insert(Symbol::intern("load-file"), load_file_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("get"), get_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/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/rust_core.rs

@@ -11,13 +11,18 @@ use crate::persistent_list::{
 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::error_message;
 
-use crate::util::IsEven;
+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
@@ -355,3 +360,35 @@ impl IFn for LoadFileFn {
         }
     }
 }
+
+// This is a tide me over rust wrapper, as map is implemented in lower level primitives
+// in pure Clojure
+// // That being said, I have not decided as to whether or not there is value to having both 
+#[derive(Debug, Clone)]
+pub struct MapFn {} 
+impl ToValue for MapFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for MapFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        if args.is_empty() {
+            return error_message::wrong_arg_count(1, args.len());
+        }
+        if let Value::IFn(ifn) = &**args.get(0).unwrap() {
+            if let Some(iterable) = args.get(1).unwrap().try_as_protocol::<Iterable>() {
+                return iterable.iter().map(|rc_val| {
+                    Rc::new(ifn.invoke(vec![rc_val]))
+                }).collect::<PersistentList>().to_value();
+            }
+        }
+        Value::Condition(format!(
+            "Type mismatch; Expected instance of {}, Recieved type {}",
+            TypeTag::IFn,
+            args.len()
+        ))
+       
+    }
+}
+