division symbol is now /

Author: erkkikeranen

src/clojure/core.clj

@@ -47,7 +47,7 @@
 (defmacro time [expr]
   (list (quote let) [(quote start) (quote (System/nanoTime)) (quote ret) expr]
         (quote (do
-        (println (str "Elapsed time: " (_slash_ (- (System/nanoTime) start) 1000000.0) " msecs"))
+        (println (str "Elapsed time: " (/ (- (System/nanoTime) start) 1000000.0) " msecs"))
         ret))))
 
 (defn slurp [f & opts]

src/environment.rs

@@ -249,6 +249,7 @@ impl Environment {
         let subtract_fn = rust_core::SubtractFn {};
         let multiply_fn = rust_core::MultiplyFn {};
         let divide_fn = rust_core::DivideFn {};
+        let rem_fn = rust_core::RemFn {};
         let rand_fn = rust_core::RandFn {};
         let rand_int_fn = rust_core::RandIntFn {};
         let str_fn = rust_core::StrFn {};
@@ -315,7 +316,8 @@ impl 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("/"), divide_fn.to_rc_value());
+        environment.insert(Symbol::intern("rem"), rem_fn.to_rc_value());
         environment.insert(Symbol::intern("rand"), rand_fn.to_rc_value());
         environment.insert(Symbol::intern("rand-int"), rand_int_fn.to_rc_value());
         environment.insert(Symbol::intern("let"), let_macro.to_rc_value());

src/reader.rs

@@ -148,7 +148,7 @@ fn is_period_char(chr: char) -> bool {
 ///
 /// Clojure defines a whitespace as either a comma or an unicode whitespace.
 fn is_clojure_whitespace(c: char) -> bool {
-    c.is_whitespace() || c == ',' 
+    c.is_whitespace() || c == ','
 }
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 //     End predicates
@@ -169,16 +169,16 @@ fn consume_clojure_whitespaces_parser(input: &str) -> IResult<&str, ()> {
 
     named!(whitespace_parser<&str,()>,
            value!((),
-               many0!(alt!(comment_parser | 
+               many0!(alt!(comment_parser |
                            take_while1!(is_clojure_whitespace))))
     );
 
     named!(no_whitespace_parser<&str,()>, value!((),tag!("")));
 
-    // @TODO rename / check that all parsers are consistent? 
+    // @TODO rename / check that all parsers are consistent?
     named!(parser<&str,()>,
            // Because 'whitespace_parser' loops, we cannot include the case where there's no whitespace at all in
-           // its definition -- nom wouldn't allow it, as it would loop forever consuming no whitespace 
+           // its definition -- nom wouldn't allow it, as it would loop forever consuming no whitespace
            // So instead, we eat up all the whitespace first, and then use the no_whitespace_parser as our sort-of
            // base-case after
            alt!(whitespace_parser | no_whitespace_parser)
@@ -432,6 +432,16 @@ pub fn try_read_pattern(input: &str) -> IResult<&str, Value> {
     Ok((rest_input, regex))
 }
 
+/// This reader is needed for parsing the division sign /
+pub fn try_read_division_forward_slash(input: &str) -> IResult<&str, Value> {
+    named!(slash_parser<&str, &str>, preceded!(consume_clojure_whitespaces_parser, tag!("/")));
+
+    let (rest_input, slash) = slash_parser(input)?;
+
+    // If an error is thrown,  this will be coerced into a condition
+    Ok((rest_input, Value::Symbol(Symbol::intern(slash))))
+}
+
 // @TODO Perhaps generalize this, or even generalize it as a reader macro
 /// Tries to parse &str into Value::PersistentListMap, or some other Value::..Map
 /// Example Successes:
@@ -533,6 +543,7 @@ pub fn try_read(input: &str) -> IResult<&str, Value> {
             try_read_bool,
             try_read_nil,
             try_read_symbol,
+            try_read_division_forward_slash,
             try_read_keyword,
             try_read_list,
             try_read_vector,
@@ -560,12 +571,15 @@ pub fn read<R: BufRead>(reader: &mut R) -> Value {
     // loop over and ask for more lines, accumulating them in input_buffer until we can read
     loop {
         let maybe_line = reader.by_ref().lines().next();
-        
+
         match maybe_line {
             Some(Err(e)) => return Value::Condition(format!("Reader error: {}", e)),
             // `lines` does not include \n,  but \n is part of the whitespace given to the reader
-            // (and is important for reading comments) so we will push a newline as well 
-            Some(Ok(line)) => { input_buffer.push_str(&line); input_buffer.push_str("\n"); },
+            // (and is important for reading comments) so we will push a newline as well
+            Some(Ok(line)) => {
+                input_buffer.push_str(&line);
+                input_buffer.push_str("\n");
+            }
             None => {
                 return Value::Condition(String::from("Tried to read empty stream; unexpected EOF"))
             }
@@ -881,6 +895,14 @@ mod tests {
         fn try_read_bool_false_test() {
             assert_eq!(Value::Boolean(false), try_read("false ").ok().unwrap().1)
         }
+
+        #[test]
+        fn try_read_forward_slash_test() {
+            assert_eq!(
+                Value::Symbol(Symbol::intern(&"/")),
+                try_read("/ ").ok().unwrap().1
+            );
+        }
     }
 
     mod regex_tests {

src/rust_core.rs

@@ -29,6 +29,9 @@ pub use self::_divide_::*;
 pub(crate) mod _multiply_;
 pub use self::_multiply_::*;
 
+pub(crate) mod rem;
+pub use self::rem::*;
+
 pub(crate) mod rand;
 pub use self::rand::*;
 

src/rust_core/_divide_.rs

@@ -20,6 +20,8 @@ impl IFn for DivideFn {
             1 => {
                 let val = args.get(0).unwrap().to_value();
                 match val {
+                    Value::I32(0) => Value::Condition("Divide by zero".to_string()),
+                    Value::F64(0.0) => Value::Condition("Divide by zero".to_string()),
                     Value::I32(a_) => Value::F64(1.0 / a_ as f64),
                     Value::F64(f_) => Value::F64(1.0 / f_),
                     _ => Value::Condition(format!(
@@ -34,6 +36,8 @@ impl IFn for DivideFn {
                 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(0) => Value::Condition("Divide by zero".to_string()),
+                        Value::F64(0.0) => Value::Condition("Divide by zero".to_string()),
                         Value::I32(b_) => Value::I32(a_ / b_),
                         Value::F64(b_) => Value::F64(a_ as f64 / b_),
                         _ => Value::Condition(format!(
@@ -43,6 +47,8 @@ impl IFn for DivideFn {
                         )),
                     },
                     Value::F64(a_) => match *b {
+                        Value::I32(0) => Value::Condition("Divide by zero".to_string()),
+                        Value::F64(0.0) => Value::Condition("Divide by zero".to_string()),
                         Value::I32(b_) => Value::F64(a_ / b_ as f64),
                         Value::F64(b_) => Value::F64(a_ / b_),
                         _ => Value::Condition(format!(

src/rust_core/rem.rs

@@ -0,0 +1,82 @@
+use crate::ifn::IFn;
+use crate::value::{ToValue, Value};
+use std::rc::Rc;
+
+use crate::error_message;
+
+/// (rem x y)
+/// Calculate remainder
+#[derive(Debug, Clone)]
+pub struct RemFn {}
+impl ToValue for RemFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for RemFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        match args.len() {
+            2 => {
+                match args.get(0).unwrap().to_value() {
+                    Value::I32(a_) => match args.get(1).unwrap().to_value() {
+                        Value::I32(0) => Value::Condition("Divide by zero".to_string()),
+                        Value::F64(0.0) => Value::Condition("Divide by zero".to_string()),
+                        Value::I32(b_) => Value::I32(a_ % b_),
+                        Value::F64(b_) => Value::F64(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(1).unwrap().to_value() {
+                        Value::I32(0) => Value::Condition("Divide by zero".to_string()),
+                        Value::F64(0.0) => Value::Condition("Divide by zero".to_string()),
+                        Value::I32(b_) => Value::F64(a_ % b_ as f64),
+                        Value::F64(b_) => Value::F64(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()
+                    )),
+                }
+            }
+            _ => error_message::wrong_arg_count(2, args.len()),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    mod rem_tests {
+        use crate::ifn::IFn;
+        use crate::rust_core::rem::RemFn;
+        use crate::value::Value;
+        use std::rc::Rc;
+
+        #[test]
+        fn rem_without_arguments_returns_error() {
+            let rem = RemFn {};
+            let args = vec![];
+            assert_eq!(
+                Value::Condition(String::from(
+                    "Wrong number of arguments given to function (Given: 0, Expected: 2)"
+                )),
+                rem.invoke(args)
+            );
+        }
+
+        #[test]
+        fn rem_with_two_integer_argument_returns_remainder() {
+            let rem = RemFn {};
+            let args = vec![Rc::new(Value::I32(10)), Rc::new(Value::I32(3))];
+            assert_eq!(Value::I32(1), rem.invoke(args));
+        }
+    }
+}

src/symbol.rs

@@ -28,8 +28,12 @@ impl Symbol {
             //       we need to make sure each 'character' in this case
             //       is 1 byte, and not some other grapheme abstraction
             //       else,these are two different indexes
-            ns = &name[..ind];
-            name = &name[ind + 1..];
+
+            // support interning of the symbol '/' for division
+            if ind > 0 || name.len() > 1 {
+                ns = &name[..ind];
+                name = &name[ind + 1..];
+            }
         }
         Symbol::intern_with_ns(ns, name)
     }