divide, multiply, subtract with unittests, clojure inc and dec functions, temporary _slash_ name for division function in environment

Author: erkkikeranen

src/clojure/core.clj

@@ -10,3 +10,9 @@
 
 (defn println [& more]
   (print-string (apply str more)))
+
+(defn inc [x]
+  (+ x 1))
+
+(defn dec [x]
+  (- x 1))

src/environment.rs

@@ -71,6 +71,9 @@ impl Environment {
     pub fn clojure_core_environment() -> Rc<Environment> {
         // Register our macros / functions ahead of time
         let add_fn = rust_core::AddFn {};
+        let subtract_fn = rust_core::_subtract_::SubtractFn {};
+        let multiply_fn = rust_core::_multiply_::MultiplyFn {};
+        let divide_fn = rust_core::_divide_::DivideFn {};
         let str_fn = rust_core::StrFn {};
         let do_fn = rust_core::DoFn {};
         let nth_fn = rust_core::NthFn {};
@@ -94,6 +97,9 @@ impl Environment {
         let eval_fn = rust_core::EvalFn::new(Rc::clone(&environment));
 
         environment.insert(Symbol::intern("+"), add_fn.to_rc_value());
+        environment.insert(Symbol::intern("-"), subtract_fn.to_rc_value());
+        environment.insert(Symbol::intern("*"), multiply_fn.to_rc_value());
+        environment.insert(Symbol::intern("_slash_"), divide_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("quote"), quote_macro.to_rc_value());

src/error_message.rs

@@ -25,6 +25,11 @@ pub fn wrong_varg_count(expected: &[usize], got: usize) -> Value {
     ))
 }
 
+pub fn zero_arg_count(got: usize) -> Value {
+    Value::Condition(format!(
+        "Wrong number of arguments given to function (Given: {})", got))
+}
+
 pub fn index_out_of_bounds(ind: usize, count: usize) -> Value {
     Value::Condition(format!(
         "Index out of bounds: Index ({}), Length: ({})",

src/rust_core.rs

@@ -19,6 +19,10 @@ use crate::error_message;
 
 use crate::util::IsEven;
 
+pub(crate) mod _subtract_;
+pub(crate) mod _divide_;
+pub(crate) mod _multiply_;
+
 // 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
 

src/rust_core/_divide_.rs

@@ -0,0 +1,127 @@
+use crate::ifn::IFn;
+use crate::value::{Value, ToValue};
+use std::rc::Rc;
+
+use crate::error_message;
+
+/// (/ x y & xys)
+///
+#[derive(Debug, Clone)]
+pub struct DivideFn {}
+impl ToValue for DivideFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for DivideFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        match args.len() {
+            0 =>  { error_message::zero_arg_count(args.len()) },
+            1 => {
+                let val = args.get(0).unwrap().to_value();
+                match val {
+                    Value::I32(a_) => Value::F64(1.0 / a_ as f64),
+                    Value::F64(f_) => Value::F64(1.0 / f_),
+                    _ => Value::Condition(format!( // TODO: what error message should be returned regarding using typetags?
+                                                   "Type mismatch; Expecting: (i32 | i64 | f32 | f64), Found: {}",
+                                                   val.type_tag()
+                    ))
+                }
+            },
+            _ => {
+                let mut args_iterator = args.into_iter();
+                let first_arg = args_iterator.next().unwrap();
+                args_iterator.fold(first_arg.to_value(), |a, b| match a {
+                    Value::I32(a_) => match *b {
+                        Value::I32(b_) => Value::I32(a_ / b_),
+                        Value::F64(b_) => Value::F64(a_ as f64 / b_),
+                        _ => Value::Condition(format!( // TODO: what error message should be returned regarding using typetags?
+                                                       "Type mismatch; Expecting: (i32 | i64 | f32 | f64), Found: {}",
+                                                       b.type_tag()
+                        )),
+                    },
+                    Value::F64(a_) => match *b {
+                        Value::I32(b_) => Value::F64(a_ / b_ as f64),
+                        Value::F64(b_) => Value::F64(a_ / b_),
+                        _ => Value::Condition(format!( // TODO: what error message should be returned regarding using typetags?
+                                                       "Type mismatch; Expecting: (i32 | i64 | f32 | f64), Found: {}",
+                                                       b.type_tag()
+                        )),
+                    },
+                    _ => Value::Condition(format!( // TODO: what error message should be returned regarding using typetags?
+                                                   "Type mismatch: Expecting: (i32 | i64 | f32 | f64), Found: {}",
+                                                   a.type_tag()
+                    )),
+                })
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    mod Divide_tests {
+        use crate::rust_core::_divide_::DivideFn;
+        use crate::ifn::IFn;
+        use crate::value::Value;
+        use std::rc::Rc;
+
+        #[test]
+        fn Divide_without_arguments_returns_one() {
+            let Divide = DivideFn {};
+            let args = vec![];
+            assert_eq!(Value::Condition(String::from("Wrong number of arguments given to function (Given: 0)")),
+                       Divide.invoke(args));
+        }
+
+        #[test]
+        fn Divide_with_one_positive_argument_returns_reciprocal() {
+            let divide = DivideFn {};
+            let args = vec![Rc::new(Value::I32(5))];
+            assert_eq!(Value::F64(1.0/5.0), divide.invoke(args));
+        }
+
+        #[test]
+        fn Divide_with_one_negative_argument_returns_reciprocal() {
+            let divide = DivideFn {};
+            let args = vec![Rc::new(Value::I32(-5))];
+            assert_eq!(Value::F64(1.0 / -5.0), divide.invoke(args));
+        }
+
+        #[test]
+        fn Divide_with_two_integer_argument_returns_quotient() {
+            let divide = DivideFn {};
+            let args = vec![Rc::new(Value::I32(24)), Rc::new(Value::I32(6))];
+            assert_eq!(Value::I32(4), divide.invoke(args));
+        }
+
+        #[test]
+        fn Divide_with_one_double_argument_returns_quotient() {
+            let divide = DivideFn {};
+            let args = vec![Rc::new(Value::I32(24)), Rc::new(Value::F64(1.5))];
+            assert_eq!(Value::F64(16.0), divide.invoke(args));
+        }
+
+        #[test]
+        fn Divide_with_multiple_integer_arguments_returns_quotient() {
+            let Divide = DivideFn {};
+            let args = vec![
+                Rc::new(Value::I32(100)),
+                Rc::new(Value::I32(5)),
+                Rc::new(Value::I32(4))];
+            assert_eq!(Value::I32(5), Divide.invoke(args));
+        }
+
+        #[test]
+        fn Divide_with_multiple_mixed_arguments_returns_quotient() {
+            let Divide = DivideFn {};
+            let args = vec![
+                Rc::new(Value::I32(100)),
+                Rc::new(Value::I32(5)),
+                Rc::new(Value::I32(4)),
+                Rc::new(Value::F64(2.0))];
+            assert_eq!(Value::F64(2.5), Divide.invoke(args));
+        }
+
+    }
+}

src/rust_core/_multiply_.rs

@@ -0,0 +1,71 @@
+use crate::ifn::IFn;
+use crate::value::{Value, ToValue};
+use std::rc::Rc;
+
+/// (* x y & xys)
+///
+#[derive(Debug, Clone)]
+pub struct MultiplyFn {}
+impl ToValue for MultiplyFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for MultiplyFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        args.into_iter().fold(1_i32.to_value(), |a, b| match a {
+            Value::I32(a_) => match *b {
+                Value::I32(b_) => Value::I32(a_ * b_),
+                Value::F64(b_) => Value::F64(a_ as f64 * b_),
+                _ => Value::Condition(format!( // TODO: what error message should be returned regarding using typetags?
+                                               "Type mismatch; Expecting: (i32 | i64 | f32 | f64), Found: {}",
+                                               b.type_tag()
+                )),
+            },
+            Value::F64(a_) => match *b {
+                Value::I32(b_) => Value::F64(a_ * b_ as f64),
+                Value::F64(b_) => Value::F64(a_ * b_),
+                _ => Value::Condition(format!( // TODO: what error message should be returned regarding using typetags?
+                                               "Type mismatch; Expecting: (i32 | i64 | f32 | f64), Found: {}",
+                                               b.type_tag()
+                )),
+            },
+            _ => Value::Condition(format!( // TODO: what error message should be returned regarding using typetags?
+                                           "Type mismatch: Expecting: (i32 | i64 | f32 | f64), Found: {}",
+                                           a.type_tag()
+            )),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    mod multiply_tests {
+        use crate::rust_core::_multiply_::MultiplyFn;
+        use crate::ifn::IFn;
+        use crate::value::Value;
+        use std::rc::Rc;
+
+        #[test]
+        fn multiply_without_arguments_returns_one() {
+            let multiply = MultiplyFn {};
+            let args = vec![];
+            assert_eq!(Value::I32(1), multiply.invoke(args));
+        }
+
+        #[test]
+        fn multiply_with_one_argument_returns_identity() {
+            let multiply = MultiplyFn {};
+            let args = vec![Rc::new(Value::I32(5))];
+            assert_eq!(Value::I32(5), multiply.invoke(args));
+        }
+
+        #[test]
+        fn multiply_with_two_argument_returns_product() {
+            let multiply = MultiplyFn {};
+            let args = vec![Rc::new(Value::I32(5)), Rc::new(Value::I32(6))];
+            assert_eq!(Value::I32(30), multiply.invoke(args));
+        }
+
+    }
+}

src/rust_core/_subtract_.rs

@@ -0,0 +1,127 @@
+use crate::ifn::IFn;
+use crate::value::{Value, ToValue};
+use std::rc::Rc;
+
+use crate::error_message;
+
+/// (- x y & xys)
+///
+#[derive(Debug, Clone)]
+pub struct SubtractFn {}
+impl ToValue for SubtractFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for SubtractFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        match args.len() {
+            0 =>  { error_message::zero_arg_count(args.len()) },
+            1 => {
+                let val = args.get(0).unwrap().to_value();
+                match val {
+                    Value::I32(a_) => Value::I32(-a_),
+                    Value::F64(f_) => Value::F64(-f_),
+                    _ => Value::Condition(format!( // TODO: what error message should be returned regarding using typetags?
+                                                   "Type mismatch; Expecting: (i32 | i64 | f32 | f64), Found: {}",
+                                                   val.type_tag()
+                    ))
+                }
+            },
+            _ => {
+                let mut args_iterator = args.into_iter();
+                let first_arg = args_iterator.next().unwrap();
+                args_iterator.fold(first_arg.to_value(), |a, b| match a {
+                    Value::I32(a_) => match *b {
+                        Value::I32(b_) => Value::I32(a_ - b_),
+                        Value::F64(b_) => Value::F64(a_ as f64 - b_),
+                        _ => Value::Condition(format!( // TODO: what error message should be returned regarding using typetags?
+                                                       "Type mismatch; Expecting: (i32 | i64 | f32 | f64), Found: {}",
+                                                       b.type_tag()
+                        )),
+                    },
+                    Value::F64(a_) => match *b {
+                        Value::I32(b_) => Value::F64(a_ - b_ as f64),
+                        Value::F64(b_) => Value::F64(a_ - b_),
+                        _ => Value::Condition(format!( // TODO: what error message should be returned regarding using typetags?
+                                                       "Type mismatch; Expecting: (i32 | i64 | f32 | f64), Found: {}",
+                                                       b.type_tag()
+                        )),
+                    },
+                    _ => Value::Condition(format!( // TODO: what error message should be returned regarding using typetags?
+                                                   "Type mismatch: Expecting: (i32 | i64 | f32 | f64), Found: {}",
+                                                   a.type_tag()
+                    )),
+                })
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    mod subtract_tests {
+        use crate::rust_core::_subtract_::SubtractFn;
+        use crate::ifn::IFn;
+        use crate::value::Value;
+        use std::rc::Rc;
+
+        #[test]
+        fn subtract_without_arguments_returns_one() {
+            let subtract = SubtractFn {};
+            let args = vec![];
+            assert_eq!(Value::Condition(String::from("Wrong number of arguments given to function (Given: 0)")),
+                       subtract.invoke(args));
+        }
+
+        #[test]
+        fn subtract_with_one_positive_argument_returns_negated_value() {
+            let subtract = SubtractFn {};
+            let args = vec![Rc::new(Value::I32(5))];
+            assert_eq!(Value::I32(-5), subtract.invoke(args));
+        }
+
+        #[test]
+        fn subtract_with_one_negative_argument_returns_positive_value() {
+            let subtract = SubtractFn {};
+            let args = vec![Rc::new(Value::I32(-5))];
+            assert_eq!(Value::I32(5), subtract.invoke(args));
+        }
+
+        #[test]
+        fn subtract_with_two_argument_returns_negative_difference() {
+            let subtract = SubtractFn {};
+            let args = vec![Rc::new(Value::I32(5)), Rc::new(Value::I32(6))];
+            assert_eq!(Value::I32(-1), subtract.invoke(args));
+        }
+
+        #[test]
+        fn subtract_with_two_argument_returns_positive_difference() {
+            let subtract = SubtractFn {};
+            let args = vec![Rc::new(Value::I32(6)), Rc::new(Value::I32(5))];
+            assert_eq!(Value::I32(1), subtract.invoke(args));
+        }
+
+        #[test]
+        fn subtract_with_multiple_arguments_returns_difference_case1() {
+            let subtract = SubtractFn {};
+            let args = vec![
+                Rc::new(Value::I32(-3)),
+                Rc::new(Value::I32(7)),
+                Rc::new(Value::I32(7)),
+                Rc::new(Value::I32(4))];
+            assert_eq!(Value::I32(-21), subtract.invoke(args));
+        }
+
+        #[test]
+        fn subtract_with_multiple_arguments_returns_difference_case2() {
+            let subtract = SubtractFn {};
+            let args = vec![
+                Rc::new(Value::I32(-3)),
+                Rc::new(Value::I32(7)),
+                Rc::new(Value::I32(-7)),
+                Rc::new(Value::I32(-4))];
+            assert_eq!(Value::I32(1), subtract.invoke(args));
+        }
+    }
+}