f64 type, addition works with floats and ints together

Author: erkkikeranen

src/reader.rs

@@ -122,6 +122,13 @@ fn is_minus_char(chr: char) -> bool {
     chr == '-'
 }
 
+/// Returns true if given character is a period character
+///   - `-`,
+fn is_period_char(chr: char) -> bool {
+    chr == '.'
+}
+
+
 /// Parses valid Clojure identifiers
 /// Example Successes: ab,  cat,  -12+3, |blah|, <well>
 /// Example Failures:  'a,  12b,   ,cat  
@@ -173,6 +180,31 @@ pub fn integer_parser(input: &str) -> IResult<&str, i32> {
     integer_lexer(input).map(|(rest, digits)| (rest, digits.parse().unwrap()))
 }
 
+/// Parses valid doubles
+/// Example Successes: -1.0, 0.023, 1234.3223423
+///
+///
+pub fn double_parser(input: &str) -> IResult<&str, f64> {
+    named!(integer_sign<&str, &str>,
+       map!(
+           opt!(take_while_m_n!(1, 1, is_minus_char)),
+           |maybe_minus| maybe_minus.unwrap_or("")
+       )
+    );
+    named!(integer_part<&str, &str>, take_while1!(|c: char| c.is_digit(10)));
+    named!(decimal_point<&str, &str>, take_while_m_n!(1, 1, is_period_char));
+    named!(decimal_part<&str, &str>, take_while1!(|c: char| c.is_digit(10)));
+    named!(double_lexer <&str, String>,
+         do_parse!(
+             sign: integer_sign >>
+             integer: integer_part >>
+             point: decimal_point >>
+             decimal: decimal_part >>
+             (format!("{}{}{}{}",sign,integer, point, decimal))
+         )
+    );
+    double_lexer(input).map(|(rest, digits)| (rest, digits.parse().unwrap()))
+}
 // Currently used to create 'try_readers', which are readers (or
 // reader functions, at least) that are basically composable InputType
 // -> IResult<InputType,Value> parsers, that our normal read function
@@ -214,7 +246,14 @@ pub fn try_read_bool(input: &str) -> IResult<&str, Value> {
     Ok((rest_input, Value::Boolean(bool.parse().unwrap())))
 }
 
-// Perhaps generalize this into reader macros 
+
+/// Tries to parse &str into Value::double
+///
+pub fn try_read_f64(input: &str) -> IResult<&str, Value> {
+    to_value_parser(double_parser)(input)
+}
+
+// Perhaps generalize this into reader macros
 /// Tries to parse &str into Value::Keyword 
 /// Example Successes:
 ///    :a                    => Value::Keyword(Keyword { sym: Symbol { name: "a" })
@@ -337,6 +376,7 @@ pub fn try_read(input: &str) -> IResult<&str, Value> {
         alt((
             try_read_map,
             try_read_string,
+            try_read_f64,
             try_read_i32,
             try_read_bool,
             try_read_symbol,
@@ -485,8 +525,30 @@ mod tests {
         }
     }
 
+    mod double_parser_tests {
+        use crate::reader::double_parser;
+
+        #[test]
+        fn double_parser_parses_negative_one() {
+            let s = "-1.2 ";
+            assert_eq!(Some((" ", -1.2)), double_parser(s).ok());
+        }
+
+        #[test]
+        fn double_parser_parses_one() {
+            let s = "1.12 ";
+            assert_eq!(Some((" ", 1.12)), double_parser(s).ok());
+        }
+
+        #[test]
+        fn double_parser_parses_integer_zero() {
+            let s = "0.0001 ";
+            assert_eq!(Some((" ", 0.0001)), double_parser(s).ok());
+        }
+    }
+
     mod integer_parser_tests {
-        use crate::reader::{debug_try_read, integer_parser};
+        use crate::reader::{integer_parser};
 
         #[test]
         fn integer_parser_parses_integer_one() {

src/rust_core.rs

@@ -70,11 +70,20 @@ impl IFn for AddFn {
         args.into_iter().fold(0_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()

src/type_tag.rs

@@ -3,6 +3,7 @@ use std::fmt;
 #[derive(Debug, Clone)]
 pub enum TypeTag {
     I32,
+    F64,
     Boolean,
     Symbol,
     Keyword,
@@ -26,6 +27,7 @@ impl fmt::Display for TypeTag {
         let str = match self {
             I32 => std::string::String::from("rust.std.i32"),
             Boolean => std::string::String::from("rust.std.bool"),
+            F64 => std::string::String::from("rust.std.f64"),
             Symbol => std::string::String::from("clojure.lang.Symbol"),
 	        Keyword => std::string::String::from("clojure.lang.Keyword"),
             IFn => std::string::String::from("clojure.lang.Function"),

src/value.rs

@@ -28,6 +28,7 @@ use std::rc::Rc;
 #[derive(Debug, Clone)]
 pub enum Value {
     I32(i32),
+    F64(f64),
     Boolean(bool),
     Symbol(Symbol),
     Keyword(Keyword),
@@ -75,6 +76,12 @@ impl PartialEq for Value {
             }
         }
 
+        if let F64(d) = self {
+            if let F64(d2) = other {
+                return d == d2;
+            }
+        }
+
         if let Boolean(b) = self {
             if let Boolean(b2) = other {
                 return b == b2;
@@ -187,6 +194,7 @@ impl Hash for Value {
     fn hash<H: Hasher>(&self, state: &mut H) {
         match self {
             I32(i) => i.hash(state),
+            F64(d) => d.to_value().hash(state),
             Boolean(b) => b.hash(state),
             Symbol(sym) => sym.hash(state),
 	    Keyword(kw) => kw.hash(state),
@@ -224,6 +232,7 @@ impl fmt::Display for Value {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let str = match self {
             I32(val) => val.to_string(),
+            F64(val) => val.to_string(),
             Boolean(val) => val.to_string(),
             Symbol(sym) => sym.to_string(),
 	    Keyword(kw) => kw.to_string(),
@@ -263,6 +272,7 @@ impl Value {
     pub fn type_tag(&self) -> TypeTag {
         match self {
             Value::I32(_) => TypeTag::I32,
+            Value::F64(_) => TypeTag::F64,
             Value::Boolean(_) => TypeTag::Boolean,
             Value::Symbol(_) => TypeTag::Symbol,
 	    Value::Keyword(_) => TypeTag::Keyword,
@@ -600,6 +610,11 @@ impl ToValue for i32 {
         Value::I32(*self)
     }
 }
+impl ToValue for f64 {
+    fn to_value(&self) -> Value {
+        Value::F64(*self)
+    }
+}
 impl ToValue for bool {
     fn to_value(&self) -> Value {
         Value::Boolean(*self)