adds count

clojure.core/count

Author: erkkikeranen

src/environment.rs

@@ -245,7 +245,7 @@ impl Environment {
             }
         }
     }
-    // @TODO refactor to use ^ 
+    // @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)
@@ -339,6 +339,7 @@ impl Environment {
         let meta_fn = rust_core::MetaFn::new(Rc::clone(&environment));
         let with_meta_fn = rust_core::WithMetaFn::new(Rc::clone(&environment));
         let var_fn = rust_core::special_form::VarFn::new(Rc::clone(&environment));
+        let count_fn = rust_core::count::CountFn {};
         // @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
@@ -361,6 +362,12 @@ impl Environment {
         environment.insert(Symbol::intern("with-meta"), with_meta_fn.to_rc_value());
         environment.insert(Symbol::intern("var-fn*"), var_fn.to_rc_value());
 
+        environment.insert_into_namespace(
+            &Symbol::intern("clojure.core"),
+            Symbol::intern("count"),
+            count_fn.to_rc_value(),
+        );
+
         // Thread namespace
         environment.insert_into_namespace(
             &Symbol::intern("Thread"),
@@ -463,7 +470,6 @@ impl Environment {
             split_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());

src/rust_core.rs

@@ -65,6 +65,8 @@ pub(crate) mod first;
 pub use self::first::*;
 pub(crate) mod second;
 pub use self::second::*;
+pub(crate) mod count;
+pub use self::count::*;
 
 // input and output
 pub(crate) mod system_newline;

src/rust_core/count.rs

@@ -0,0 +1,81 @@
+use crate::ifn::IFn;
+use crate::value::{ToValue, Value};
+use std::rc::Rc;
+
+use crate::error_message;
+use crate::iterable::Iterable;
+use crate::persistent_list::ToPersistentList;
+use crate::protocol::ProtocolCastable;
+use crate::type_tag::TypeTag;
+
+/// (count coll)
+/// counts items in coll
+#[derive(Debug, Clone)]
+pub struct CountFn {}
+impl ToValue for CountFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for CountFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        if args.len() != 1 {
+            return error_message::wrong_arg_count(1, args.len());
+        }
+
+        let coll_size = match args.get(0).unwrap().try_as_protocol::<Iterable>() {
+            Some(iterable) => iterable.iter().count(),
+            None => match args.get(0).unwrap().to_value() {
+                Value::Nil => 0,
+                _unsupported => return error_message::type_mismatch(TypeTag::ISeq, &_unsupported),
+            },
+        };
+
+        return Value::I32(coll_size as i32);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    mod count_tests {
+        use crate::ifn::IFn;
+        use crate::persistent_vector::PersistentVector;
+        use crate::rust_core::CountFn;
+        use crate::value::Value;
+        use std::rc::Rc;
+
+        #[test]
+        fn count_nil() {
+            let count = CountFn {};
+            let args = vec![Rc::new(Value::Nil)];
+            assert_eq!(Value::I32(0), count.invoke(args));
+        }
+
+        #[test]
+        fn count_vector() {
+            let count = CountFn {};
+            let args = vec![Rc::new(Value::PersistentVector(
+                vec![
+                    Rc::new(Value::String(String::from("1"))),
+                    Rc::new(Value::String(String::from("2"))),
+                ]
+                .into_iter()
+                .collect::<PersistentVector>(),
+            ))];
+            assert_eq!(Value::I32(2), count.invoke(args));
+        }
+
+        #[test]
+        fn count_something_unsupported() {
+            let count = CountFn {};
+            let args = vec![Rc::new(Value::Boolean(true))];
+            assert_eq!(
+                Value::Condition(
+                    "Type mismatch; Expected instance of clojure.lang.ISeq,  Recieved type true"
+                        .to_string()
+                ),
+                count.invoke(args)
+            );
+        }
+    }
+}

src/rust_core/refer.rs

@@ -2,7 +2,7 @@ use crate::environment::Environment;
 use crate::error_message;
 use crate::ifn::IFn;
 use crate::keyword::Keyword;
-use crate::persistent_vector::{ToPersistentVectorIter};
+use crate::persistent_vector::ToPersistentVectorIter;
 use crate::symbol::Symbol;
 use crate::type_tag::TypeTag;
 use crate::util::IsOdd;