Merge branch 'feature/lt-gt-lte-gte' [#69]

Author: Tko1

src/environment.rs

@@ -340,6 +340,10 @@ impl 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 {};
+        let lt_fn = rust_core::lt::LtFn {};
+        let gt_fn = rust_core::gt::GtFn {};
+        let lte_fn = rust_core::lte::LteFn {};
+        let gte_fn = rust_core::gte::GteFn {};
         // @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
@@ -368,6 +372,14 @@ impl Environment {
             count_fn.to_rc_value(),
         );
 
+        // Interop to read real clojure.core
+        environment.insert(Symbol::intern("lt"),lt_fn.to_rc_value());
+
+        environment.insert(Symbol::intern("gt"),gt_fn.to_rc_value());
+        environment.insert(Symbol::intern("lte"),lte_fn.to_rc_value());
+
+        environment.insert(Symbol::intern("gte"),gte_fn.to_rc_value());
+
         // Thread namespace
         environment.insert_into_namespace(
             &Symbol::intern("Thread"),

src/rust_core.rs

@@ -43,6 +43,18 @@ pub use self::rand::*;
 pub(crate) mod rand_int;
 pub use self::rand_int::*;
 
+pub(crate) mod lt;
+pub use self::lt::*;
+
+pub(crate) mod lte;
+pub use self::lte::*;
+
+pub(crate) mod gt;
+pub use self::gt::*;
+
+pub(crate) mod gte;
+pub use self::gte::*;
+
 // string
 pub(crate) mod str;
 pub use self::str::*;

src/rust_core/gt.rs

@@ -0,0 +1,77 @@
+use crate::error_message;
+use crate::ifn::IFn;
+use crate::value::{ToValue, Value};
+use std::rc::Rc;
+
+/// (gt x y)
+/// x > y
+#[derive(Debug, Clone)]
+pub struct GtFn {}
+impl ToValue for GtFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for GtFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        if args.len() != 2 {
+            return error_message::wrong_arg_count(2, args.len());
+        }
+        match args.get(0).unwrap().to_value() {
+            Value::I32(a) => match args.get(1).unwrap().to_value() {
+                Value::I32(b) => Value::Boolean(a > b),
+                Value::F64(b) => Value::Boolean(a > b as i32),
+                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 args.get(0).unwrap().to_value() {
+                Value::I32(b) => Value::Boolean(a > b as f64),
+                Value::F64(b) => Value::Boolean(a > b),
+                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()
+                )),
+            },
+            a_ => 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 gt_tests {
+        use crate::ifn::IFn;
+        use crate::rust_core::GtFn;
+        use crate::value::Value;
+        use std::rc::Rc;
+
+        #[test]
+        fn one_is_greater_than_zero() {
+            let gt = GtFn {};
+            let args = vec![Rc::new(Value::I32(1)), Rc::new(Value::I32(0))];
+            assert_eq!(Value::Boolean(true), gt.invoke(args));
+        }
+
+        #[test]
+        fn one_is_not_greater_than_one() {
+            let gt = GtFn {};
+            let args = vec![Rc::new(Value::I32(1)), Rc::new(Value::I32(1))];
+            assert_eq!(Value::Boolean(false), gt.invoke(args));
+        }
+
+        #[test]
+        fn one_is_not_greater_than_one_and_fractions() {
+            let gt = GtFn {};
+            let args = vec![Rc::new(Value::I32(1)), Rc::new(Value::F64(1.00001))];
+            assert_eq!(Value::Boolean(false), gt.invoke(args));
+        }
+    }
+}

src/rust_core/gte.rs

@@ -0,0 +1,77 @@
+use crate::error_message;
+use crate::ifn::IFn;
+use crate::value::{ToValue, Value};
+use std::rc::Rc;
+
+/// (gte x y)
+/// x >= y
+#[derive(Debug, Clone)]
+pub struct GteFn {}
+impl ToValue for GteFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for GteFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        if args.len() != 2 {
+            return error_message::wrong_arg_count(2, args.len());
+        }
+        match args.get(0).unwrap().to_value() {
+            Value::I32(a) => match args.get(1).unwrap().to_value() {
+                Value::I32(b) => Value::Boolean(a >= b),
+                Value::F64(b) => Value::Boolean(a as f64 >= b),
+                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 args.get(0).unwrap().to_value() {
+                Value::I32(b) => Value::Boolean(a >= b as f64),
+                Value::F64(b) => Value::Boolean(a >= b),
+                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()
+                )),
+            },
+            a_ => 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 gte_tests {
+        use crate::ifn::IFn;
+        use crate::rust_core::GteFn;
+        use crate::value::Value;
+        use std::rc::Rc;
+
+        #[test]
+        fn one_is_greater_than_zero() {
+            let gte = GteFn {};
+            let args = vec![Rc::new(Value::I32(1)), Rc::new(Value::I32(0))];
+            assert_eq!(Value::Boolean(true), gte.invoke(args));
+        }
+
+        #[test]
+        fn one_is_gte_than_one() {
+            let gte = GteFn {};
+            let args = vec![Rc::new(Value::I32(1)), Rc::new(Value::I32(1))];
+            assert_eq!(Value::Boolean(true), gte.invoke(args));
+        }
+
+        #[test]
+        fn one_is_not_gte_than_one_and_fractions() {
+            let gte = GteFn {};
+            let args = vec![Rc::new(Value::I32(1)), Rc::new(Value::F64(1.00001))];
+            assert_eq!(Value::Boolean(false), gte.invoke(args));
+        }
+    }
+}

src/rust_core/lt.rs

@@ -0,0 +1,77 @@
+use crate::error_message;
+use crate::ifn::IFn;
+use crate::value::{ToValue, Value};
+use std::rc::Rc;
+
+/// (lt x y)
+/// x < y
+#[derive(Debug, Clone)]
+pub struct LtFn {}
+impl ToValue for LtFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for LtFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        if args.len() != 2 {
+            return error_message::wrong_arg_count(2, args.len());
+        }
+        match args.get(0).unwrap().to_value() {
+            Value::I32(a) => match args.get(1).unwrap().to_value() {
+                Value::I32(b) => Value::Boolean(a < b),
+                Value::F64(b) => Value::Boolean(a < b as i32),
+                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 args.get(0).unwrap().to_value() {
+                Value::I32(b) => Value::Boolean(a < b as f64),
+                Value::F64(b) => Value::Boolean(a < b),
+                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()
+                )),
+            },
+            a_ => 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 lt_tests {
+        use crate::ifn::IFn;
+        use crate::rust_core::LtFn;
+        use crate::value::Value;
+        use std::rc::Rc;
+
+        #[test]
+        fn zero_is_less_than_one() {
+            let lt = LtFn {};
+            let args = vec![Rc::new(Value::I32(0)), Rc::new(Value::I32(1))];
+            assert_eq!(Value::Boolean(true), lt.invoke(args));
+        }
+
+        #[test]
+        fn one_is_not_less_than_one() {
+            let lt = LtFn {};
+            let args = vec![Rc::new(Value::I32(1)), Rc::new(Value::I32(1))];
+            assert_eq!(Value::Boolean(false), lt.invoke(args));
+        }
+
+        #[test]
+        fn one_is_less_than_one_and_fractions() {
+            let lt = LtFn {};
+            let args = vec![Rc::new(Value::I32(1)), Rc::new(Value::F64(1.00001))];
+            assert_eq!(Value::Boolean(false), lt.invoke(args));
+        }
+    }
+}

src/rust_core/lte.rs

@@ -0,0 +1,77 @@
+use crate::error_message;
+use crate::ifn::IFn;
+use crate::value::{ToValue, Value};
+use std::rc::Rc;
+
+/// (lte x y)
+/// x <= y
+#[derive(Debug, Clone)]
+pub struct LteFn {}
+impl ToValue for LteFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for LteFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        if args.len() != 2 {
+            return error_message::wrong_arg_count(2, args.len());
+        }
+        match args.get(0).unwrap().to_value() {
+            Value::I32(a) => match args.get(1).unwrap().to_value() {
+                Value::I32(b) => Value::Boolean(a <= b),
+                Value::F64(b) => Value::Boolean(a <= b as i32),
+                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 args.get(0).unwrap().to_value() {
+                Value::I32(b) => Value::Boolean(a <= b as f64),
+                Value::F64(b) => Value::Boolean(a <= b),
+                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()
+                )),
+            },
+            a_ => 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 lte_tests {
+        use crate::ifn::IFn;
+        use crate::rust_core::LteFn;
+        use crate::value::Value;
+        use std::rc::Rc;
+
+        #[test]
+        fn zero_is_lte_than_zero() {
+            let lte = LteFn {};
+            let args = vec![Rc::new(Value::I32(0)), Rc::new(Value::I32(1))];
+            assert_eq!(Value::Boolean(true), lte.invoke(args));
+        }
+
+        #[test]
+        fn one_is_lte_than_one() {
+            let lte = LteFn {};
+            let args = vec![Rc::new(Value::I32(1)), Rc::new(Value::I32(1))];
+            assert_eq!(Value::Boolean(true), lte.invoke(args));
+        }
+
+        #[test]
+        fn one_is_lte_than_one_and_fractions() {
+            let lte = LteFn {};
+            let args = vec![Rc::new(Value::I32(1)), Rc::new(Value::F64(1.00001))];
+            assert_eq!(Value::Boolean(true), lte.invoke(args));
+        }
+    }
+}