Speed up integer and float printing

README.md

@@ -41,7 +41,7 @@ fn main() {
     map.insert("y".to_string(), 2.0);
 
     let s = serde_json::to_string(&map).unwrap();
-    assert_eq!(s, "{\"x\":1,\"y\":2}");
+    assert_eq!(s, "{\"x\":1.0,\"y\":2.0}");
 
     let deserialized_map: Map<String, f64> = serde_json::from_str(&s).unwrap();
     assert_eq!(map, deserialized_map);
@@ -78,7 +78,7 @@ fn main() {
     let point = Point { x: 1.0, y: 2.0 };
 
     let s = serde_json::to_string(&point).unwrap();
-    assert_eq!(s, "{\"x\":1,\"y\":2}");
+    assert_eq!(s, "{\"x\":1.0,\"y\":2.0}");
 
     let deserialized_point: Point = serde_json::from_str(&s).unwrap();
     assert_eq!(point, deserialized_point);

json/Cargo.toml

@@ -18,3 +18,5 @@ serde = "^0.7.0"
 num-traits = "~0.1.32"
 clippy = { version = "^0.*", optional = true }
 linked-hash-map = { version = "0.0.11", optional = true }
+itoa = "0.1"
+dtoa = "0.1"

json/src/lib.rs

@@ -120,6 +120,8 @@
 extern crate num_traits;
 extern crate core;
 extern crate serde;
+extern crate itoa;
+extern crate dtoa;
 #[cfg(feature = "preserve_order")]
 extern crate linked_hash_map;
 

json/src/ser.rs

@@ -8,6 +8,9 @@ use std::num::FpCategory;
 use serde::ser;
 use super::error::{Error, ErrorCode, Result};
 
+use itoa;
+use dtoa;
+
 /// A structure for serializing Rust values into JSON.
 pub struct Serializer<W, F=CompactFormatter> {
     writer: W,
@@ -77,52 +80,52 @@ impl<W, F> ser::Serializer for Serializer<W, F>
 
     #[inline]
     fn serialize_isize(&mut self, value: isize) -> Result<()> {
-        write!(&mut self.writer, "{}", value).map_err(From::from)
+        itoa::write(&mut self.writer, value).map_err(From::from)
     }
 
     #[inline]
     fn serialize_i8(&mut self, value: i8) -> Result<()> {
-        write!(&mut self.writer, "{}", value).map_err(From::from)
+        itoa::write(&mut self.writer, value).map_err(From::from)
     }
 
     #[inline]
     fn serialize_i16(&mut self, value: i16) -> Result<()> {
-        write!(&mut self.writer, "{}", value).map_err(From::from)
+        itoa::write(&mut self.writer, value).map_err(From::from)
     }
 
     #[inline]
     fn serialize_i32(&mut self, value: i32) -> Result<()> {
-        write!(&mut self.writer, "{}", value).map_err(From::from)
+        itoa::write(&mut self.writer, value).map_err(From::from)
     }
 
     #[inline]
     fn serialize_i64(&mut self, value: i64) -> Result<()> {
-        write!(&mut self.writer, "{}", value).map_err(From::from)
+        itoa::write(&mut self.writer, value).map_err(From::from)
     }
 
     #[inline]
     fn serialize_usize(&mut self, value: usize) -> Result<()> {
-        write!(&mut self.writer, "{}", value).map_err(From::from)
+        itoa::write(&mut self.writer, value).map_err(From::from)
     }
 
     #[inline]
     fn serialize_u8(&mut self, value: u8) -> Result<()> {
-        write!(&mut self.writer, "{}", value).map_err(From::from)
+        itoa::write(&mut self.writer, value).map_err(From::from)
     }
 
     #[inline]
     fn serialize_u16(&mut self, value: u16) -> Result<()> {
-        write!(&mut self.writer, "{}", value).map_err(From::from)
+        itoa::write(&mut self.writer, value).map_err(From::from)
     }
 
     #[inline]
     fn serialize_u32(&mut self, value: u32) -> Result<()> {
-        write!(&mut self.writer, "{}", value).map_err(From::from)
+        itoa::write(&mut self.writer, value).map_err(From::from)
     }
 
     #[inline]
     fn serialize_u64(&mut self, value: u64) -> Result<()> {
-        write!(&mut self.writer, "{}", value).map_err(From::from)
+        itoa::write(&mut self.writer, value).map_err(From::from)
     }
 
     #[inline]
@@ -555,7 +558,7 @@ fn fmt_f32_or_null<W>(wr: &mut W, value: f32) -> Result<()>
             try!(wr.write_all(b"null"))
         }
         _ => {
-            try!(write!(wr, "{:?}", value))
+            try!(dtoa::write(wr, value))
         }
     }
 
@@ -570,7 +573,7 @@ fn fmt_f64_or_null<W>(wr: &mut W, value: f64) -> Result<()>
             try!(wr.write_all(b"null"))
         }
         _ => {
-            try!(write!(wr, "{:?}", value))
+            try!(dtoa::write(wr, value))
         }
     }
 

json_tests/tests/test_json.rs

@@ -117,18 +117,14 @@ fn test_write_i64() {
 
 #[test]
 fn test_write_f64() {
-    let min_string = format!("{:?}", f64::MIN);
-    let max_string = format!("{:?}", f64::MAX);
-    let epsilon_string = format!("{:?}", f64::EPSILON);
-
     let tests = &[
-        (3.0, "3"),
+        (3.0, "3.0"),
         (3.1, "3.1"),
         (-1.5, "-1.5"),
         (0.5, "0.5"),
-        (f64::MIN, &min_string),
-        (f64::MAX, &max_string),
-        (f64::EPSILON, &epsilon_string),
+        (f64::MIN, "-1.7976931348623157e308"),
+        (f64::MAX, "1.7976931348623157e308"),
+        (f64::EPSILON, "2.220446049250313e-16"),
     ];
     test_encode_ok(tests);
     test_pretty_encode_ok(tests);