Merge branch 'feature/coll-operations' [#46]

Author: Tko1

src/clojure/core.clj

@@ -1,6 +1,9 @@
 (def *flush-on-newline* true)
 (def *print-readably* true)
 
+(defmacro when [test & body]
+  (list 'if test (concat (list 'do) body)))
+
 (def list (fn [& ls] ls))
 
 (defmacro defn [name args & body]
@@ -25,7 +28,9 @@
 (defn prn [& more]
   (apply pr more)
   (newline)
-  (flush))
+  (when *flush-on-newline*
+    (flush)
+    nil))
 
 (defn print [& more]
   (apply pr more))
@@ -47,3 +52,17 @@
 
 (defn slurp [f & opts]
   (rust-slurp f opts))
+
+"basic operations on collections"
+
+(defn rest [x]
+  (more x))
+
+(defn next [x]
+  (let [result (rest x)]
+    (if (= '() result)
+      nil
+      result)))
+
+(defn ffirst [x]
+  (first (first x)))

src/clojure_string/blank_qmark_.rs

@@ -42,7 +42,7 @@ impl IFn for BlankFn {
 
 #[cfg(test)]
 mod tests {
-    mod reverse_tests {
+    mod blank_tests {
         use crate::clojure_string::blank_qmark_::BlankFn;
         use crate::ifn::IFn;
         use crate::value::Value;

src/clojure_string/ends_with_qmark_.rs

@@ -33,7 +33,7 @@ impl IFn for EndsWithFn {
 
 #[cfg(test)]
 mod tests {
-    mod reverse_tests {
+    mod ends_with_tests {
         use crate::clojure_string::ends_with_qmark_::EndsWithFn;
         use crate::ifn::IFn;
         use crate::value::Value;

src/clojure_string/includes_qmark_.rs

@@ -33,7 +33,7 @@ impl IFn for IncludesFn {
 
 #[cfg(test)]
 mod tests {
-    mod reverse_tests {
+    mod includes_tests {
         use crate::clojure_string::includes_qmark_::IncludesFn;
         use crate::ifn::IFn;
         use crate::value::Value;

src/clojure_string/join.rs

@@ -50,7 +50,7 @@ impl IFn for JoinFn {
 
 #[cfg(test)]
 mod tests {
-    mod reverse_tests {
+    mod join_tests {
         use crate::clojure_string::join::JoinFn;
         use crate::ifn::IFn;
         use crate::persistent_list::PersistentList;

src/clojure_string/starts_with_qmark_.rs

@@ -33,7 +33,7 @@ impl IFn for StartsWithFn {
 
 #[cfg(test)]
 mod tests {
-    mod reverse_tests {
+    mod starts_with_tests {
         use crate::clojure_string::starts_with_qmark_::StartsWithFn;
         use crate::ifn::IFn;
         use crate::value::Value;

src/environment.rs

@@ -194,6 +194,9 @@ impl Environment {
         let print_string_fn = rust_core::PrintStringFn {};
         let read_line_fn = rust_core::ReadLineFn {};
         let assoc_fn = rust_core::AssocFn {};
+        let more_fn = rust_core::MoreFn {};
+        let first_fn = rust_core::FirstFn {};
+        let second_fn = rust_core::SecondFn {};
 
         // rust implementations of core functions
         let slurp_fn = rust_core::slurp::SlurpFn {};
@@ -380,7 +383,9 @@ impl Environment {
         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("more"), more_fn.to_rc_value());
+        environment.insert(Symbol::intern("first"), first_fn.to_rc_value());
+        environment.insert(Symbol::intern("second"), second_fn.to_rc_value());
         // input and output
         environment.insert(
             Symbol::intern("system-newline"),

src/rust_core.rs

@@ -47,6 +47,13 @@ pub use self::get::*;
 pub(crate) mod map;
 pub use self::map::*;
 
+pub(crate) mod more;
+pub use self::more::*;
+pub(crate) mod first;
+pub use self::first::*;
+pub(crate) mod second;
+pub use self::second::*;
+
 // input and output
 pub(crate) mod system_newline;
 pub use self::system_newline::*;

src/rust_core/first.rs

@@ -0,0 +1,73 @@
+use crate::error_message;
+use crate::ifn::IFn;
+use crate::iterable::Iterable;
+use crate::persistent_list::PersistentList;
+use crate::protocol::{Protocol, ProtocolCastable};
+use crate::type_tag::TypeTag;
+use crate::value::{ToValue, Value};
+use std::rc::Rc;
+
+/// (first x)
+/// returns first element or nil
+/// TODO: support for strings
+#[derive(Debug, Clone)]
+pub struct FirstFn {}
+impl ToValue for FirstFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for FirstFn {
+    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().try_as_protocol::<Iterable>() {
+            Some(iterable) => match iterable.iter().next() {
+                Some(val) => val.to_value(),
+                _ => Value::Nil,
+            },
+            _ => error_message::type_mismatch(TypeTag::ISeq, args.get(0).unwrap()),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    mod first_tests {
+        use crate::ifn::IFn;
+        use crate::persistent_list::PersistentList;
+        use crate::persistent_vector::PersistentVector;
+        use crate::rust_core::first::FirstFn;
+        use crate::value::Value;
+        use std::rc::Rc;
+
+        #[test]
+        fn first_on_empty_iterable() {
+            let first = FirstFn {};
+            let args = vec![Rc::new(Value::PersistentList(
+                vec![].into_iter().collect::<PersistentList>(),
+            ))];
+            assert_eq!(Value::Nil, first.invoke(args));
+        }
+
+        #[test]
+        fn first_on_iterable_with_one_value_list() {
+            let first = FirstFn {};
+            let args = vec![Rc::new(Value::PersistentList(
+                vec![Rc::new(Value::Boolean(true))]
+                    .into_iter()
+                    .collect::<PersistentList>(),
+            ))];
+            assert_eq!(Value::Boolean(true), first.invoke(args));
+        }
+
+        #[test]
+        #[should_panic]
+        fn first_on_non_iterable_value() {
+            let first = FirstFn {};
+            let args = vec![Rc::new(Value::Nil)];
+            assert_eq!(Value::Nil, first.invoke(args));
+        }
+    }
+}

src/rust_core/more.rs

@@ -0,0 +1,103 @@
+use crate::error_message;
+use crate::ifn::IFn;
+use crate::iterable::Iterable;
+use crate::persistent_list::PersistentList;
+use crate::protocol::{Protocol, ProtocolCastable};
+use crate::type_tag::TypeTag;
+use crate::value::{ToValue, Value};
+use std::rc::Rc;
+
+/// (more x)
+/// for rest, returns possibly empty sequence after the first
+/// TODO: support for strings
+#[derive(Debug, Clone)]
+pub struct MoreFn {}
+impl ToValue for MoreFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for MoreFn {
+    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().try_as_protocol::<Iterable>() {
+            Some(iterable) => match iterable.iter().collect::<Vec<Rc<Value>>>().split_first() {
+                Some((_, more)) => {
+                    Value::PersistentList(more.to_vec().into_iter().collect::<PersistentList>())
+                }
+                _ => Value::PersistentList(vec![].into_iter().collect::<PersistentList>()),
+            },
+            _ => error_message::type_mismatch(TypeTag::ISeq, args.get(0).unwrap()),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    mod more_tests {
+        use crate::ifn::IFn;
+        use crate::persistent_list::PersistentList;
+        use crate::persistent_vector::PersistentVector;
+        use crate::rust_core::more::MoreFn;
+        use crate::value::Value;
+        use std::rc::Rc;
+
+        #[test]
+        fn more_on_empty_iterable() {
+            let more = MoreFn {};
+            let args = vec![Rc::new(Value::PersistentList(
+                vec![].into_iter().collect::<PersistentList>(),
+            ))];
+            assert_eq!(
+                Value::PersistentList(vec![].into_iter().collect::<PersistentList>()),
+                more.invoke(args)
+            );
+        }
+
+        #[test]
+        fn more_on_iterable_with_one_value_list() {
+            let more = MoreFn {};
+            let args = vec![Rc::new(Value::PersistentList(
+                vec![Rc::new(Value::Boolean(true))]
+                    .into_iter()
+                    .collect::<PersistentList>(),
+            ))];
+            assert_eq!(
+                Value::PersistentList(vec![].into_iter().collect::<PersistentList>()),
+                more.invoke(args)
+            );
+        }
+
+        #[test]
+        fn more_on_iterable_with_three_value_list() {
+            let more = MoreFn {};
+            let args = vec![Rc::new(Value::PersistentList(
+                vec![
+                    Rc::new(Value::I32(1)),
+                    Rc::new(Value::I32(2)),
+                    Rc::new(Value::I32(3)),
+                ]
+                .into_iter()
+                .collect::<PersistentList>(),
+            ))];
+            assert_eq!(
+                Value::PersistentList(
+                    vec![Rc::new(Value::I32(2)), Rc::new(Value::I32(3))]
+                        .into_iter()
+                        .collect::<PersistentList>()
+                ),
+                more.invoke(args)
+            );
+        }
+
+        #[test]
+        #[should_panic]
+        fn more_on_non_iterable_value() {
+            let more = MoreFn {};
+            let args = vec![Rc::new(Value::Nil)];
+            assert_eq!(Value::Nil, more.invoke(args));
+        }
+    }
+}