Fixed fmt!, tests, doc-tests.

Kimundi · Kimundi · commit cf4a9aeed94a · 2013-02-02T17:54:21.000+01:00
diff --git a/doc/rust.md b/doc/rust.md
@@ -844,7 +844,7 @@ mod quux {
         pub fn bar() { }
         pub fn baz() { }
     }
-    
+
     pub use quux::foo::*;
 }
 ~~~~
@@ -1242,7 +1242,7 @@ trait Num {
 impl float: Num {
     static pure fn from_int(n: int) -> float { n as float }
 }
-let x: float = Num::from_int(42);     
+let x: float = Num::from_int(42);
 ~~~~
 
 Traits may inherit from other traits. For example, in
@@ -1615,7 +1615,7 @@ The following are examples of structure expressions:
 ~~~~
 # struct Point { x: float, y: float }
 # struct TuplePoint(float, float);
-# mod game { pub struct User { name: &str, age: uint, mut score: uint } } 
+# mod game { pub struct User { name: &str, age: uint, mut score: uint } }
 # use game;
 Point {x: 10f, y: 20f};
 TuplePoint(10f, 20f);
@@ -2812,7 +2812,7 @@ trait Printable {
 }
 
 impl int: Printable {
-  fn to_str() -> ~str { int::to_str(self, 10) }
+  fn to_str() -> ~str { int::to_str(self) }
 }
 
 fn print(a: @Printable) {
diff --git a/doc/tutorial-tasks.md b/doc/tutorial-tasks.md
@@ -473,7 +473,7 @@ fn stringifier(channel: &DuplexStream<~str, uint>) {
     let mut value: uint;
     loop {
         value = channel.recv();
-        channel.send(uint::to_str(value, 10));
+        channel.send(uint::to_str(value));
         if value == 0 { break; }
     }
 }
@@ -497,7 +497,7 @@ Here is the code for the parent task:
 #     let mut value: uint;
 #     loop {
 #         value = channel.recv();
-#         channel.send(uint::to_str(value, 10u));
+#         channel.send(uint::to_str(value));
 #         if value == 0u { break; }
 #     }
 # }
diff --git a/src/libcore/num/num.rs b/src/libcore/num/num.rs
@@ -422,6 +422,12 @@ pub pure fn to_str_bytes_common<T: Num Zero One Eq Ord Round Copy>(
                 buf = buf.slice(0, i + 1);
             }
         }
+    } // If exact and trailing '.', just cut that
+    else {
+        let max_i = buf.len() - 1;
+        if buf[max_i] == '.' as u8 {
+            buf = buf.slice(0, max_i);
+        }
     }
 
     (buf, false)
@@ -678,4 +684,4 @@ pub pure fn from_str_common<T: Num Zero One Ord Copy>(
         ) -> Option<T> {
     from_str_bytes_common(str::to_bytes(buf), radix, negative,
                             fractional, special, exponent, empty_zero)
-}
+}
diff --git a/src/libstd/time.rs b/src/libstd/time.rs
@@ -926,7 +926,7 @@ mod tests {
         let s0 = precise_time_s();
         let ns1 = precise_time_ns();
 
-        log(debug, ~"s0=" + float::to_str(s0, 9u) + ~" sec");
+        log(debug, ~"s0=" + float::to_str_digits(s0, 9u) + ~" sec");
         assert s0 > 0.;
         let ns0 = (s0 * 1000000000.) as u64;
         log(debug, ~"ns0=" + u64::str(ns0) + ~" ns");
diff --git a/src/test/bench/core-map.rs b/src/test/bench/core-map.rs
@@ -75,12 +75,12 @@ fn old_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results) {
         let map = map::HashMap();
         do timed(&mut results.sequential_strings) {
             for uint::range(0, num_keys) |i| {
-                let s = uint::to_str(i, 10);
+                let s = uint::to_str(i);
                 map.insert(s, i);
             }
 
             for uint::range(0, num_keys) |i| {
-                let s = uint::to_str(i, 10);
+                let s = uint::to_str(i);
                 assert map.get(s) == i;
             }
         }
@@ -90,7 +90,7 @@ fn old_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results) {
         let map = map::HashMap();
         do timed(&mut results.random_strings) {
             for uint::range(0, num_keys) |i| {
-                let s = uint::to_str(rng.next() as uint, 10);
+                let s = uint::to_str(rng.next() as uint);
                 map.insert(s, i);
             }
         }
@@ -99,11 +99,11 @@ fn old_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results) {
     {
         let map = map::HashMap();
         for uint::range(0, num_keys) |i| {
-            map.insert(uint::to_str(i, 10), i);
+            map.insert(uint::to_str(i), i);
         }
         do timed(&mut results.delete_strings) {
             for uint::range(0, num_keys) |i| {
-                assert map.remove(uint::to_str(i, 10));
+                assert map.remove(uint::to_str(i));
             }
         }
     }
@@ -151,12 +151,12 @@ fn linear_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results)
         let mut map = LinearMap::new();
         do timed(&mut results.sequential_strings) {
             for uint::range(0, num_keys) |i| {
-                let s = uint::to_str(i, 10);
+                let s = uint::to_str(i);
                 map.insert(s, i);
             }
 
             for uint::range(0, num_keys) |i| {
-                let s = uint::to_str(i, 10);
+                let s = uint::to_str(i);
                 assert map.find(&s).unwrap() == &i;
             }
         }
@@ -166,7 +166,7 @@ fn linear_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results)
         let mut map = LinearMap::new();
         do timed(&mut results.random_strings) {
             for uint::range(0, num_keys) |i| {
-                let s = uint::to_str(rng.next() as uint, 10);
+                let s = uint::to_str(rng.next() as uint);
                 map.insert(s, i);
             }
         }
@@ -175,11 +175,11 @@ fn linear_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results)
     {
         let mut map = LinearMap::new();
         for uint::range(0, num_keys) |i| {
-            map.insert(uint::to_str(i, 10), i);
+            map.insert(uint::to_str(i), i);
         }
         do timed(&mut results.delete_strings) {
             for uint::range(0, num_keys) |i| {
-                assert map.remove(&uint::to_str(i, 10));
+                assert map.remove(&uint::to_str(i));
             }
         }
     }
@@ -227,12 +227,12 @@ fn tree_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results) {
         let mut map = TreeMap::new();
         do timed(&mut results.sequential_strings) {
             for uint::range(0, num_keys) |i| {
-                let s = uint::to_str(i, 10);
+                let s = uint::to_str(i);
                 map.insert(s, i);
             }
 
             for uint::range(0, num_keys) |i| {
-                let s = uint::to_str(i, 10);
+                let s = uint::to_str(i);
                 assert map.find(&s).unwrap() == &i;
             }
         }
@@ -242,7 +242,7 @@ fn tree_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results) {
         let mut map = TreeMap::new();
         do timed(&mut results.random_strings) {
             for uint::range(0, num_keys) |i| {
-                let s = uint::to_str(rng.next() as uint, 10);
+                let s = uint::to_str(rng.next() as uint);
                 map.insert(s, i);
             }
         }
@@ -251,11 +251,11 @@ fn tree_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results) {
     {
         let mut map = TreeMap::new();
         for uint::range(0, num_keys) |i| {
-            map.insert(uint::to_str(i, 10), i);
+            map.insert(uint::to_str(i), i);
         }
         do timed(&mut results.delete_strings) {
             for uint::range(0, num_keys) |i| {
-                assert map.remove(&uint::to_str(i, 10));
+                assert map.remove(&uint::to_str(i));
             }
         }
     }
diff --git a/src/test/bench/core-uint-to-str.rs b/src/test/bench/core-uint-to-str.rs
@@ -21,7 +21,7 @@ fn main() {
     let n = uint::from_str(args[1]).get();
 
     for uint::range(0u, n) |i| {
-        let x = uint::to_str(i, 10u);
+        let x = uint::to_str(i);
         log(debug, x);
     }
 }
diff --git a/src/test/run-pass/core-export-f64-sqrt.rs b/src/test/run-pass/core-export-f64-sqrt.rs
@@ -14,5 +14,5 @@ pub fn main() {
 
     let digits: uint = 10 as uint;
 
-    ::core::io::println(float::to_str(f64::sqrt(42.0f64) as float, digits));
+    ::core::io::println(float::to_str_digits(f64::sqrt(42.0f64) as float, digits));
 }

Original file line number	Diff line number	Diff line change
`@@ -422,6 +422,12 @@ pub pure fn to_str_bytes_common<T: Num Zero One Eq Ord Round Copy>(`
`422`	`422`	`buf = buf.slice(0, i + 1);`
`423`	`423`	`}`
`424`	`424`	`}`
	`425`	`+ } // If exact and trailing '.', just cut that`
	`426`	`+ else {`
	`427`	`+ let max_i = buf.len() - 1;`
	`428`	`+ if buf[max_i] == '.' as u8 {`
	`429`	`+ buf = buf.slice(0, max_i);`
	`430`	`+ }`
`425`	`431`	`}`
`426`	`432`
`427`	`433`	`(buf, false)`
`@@ -678,4 +684,4 @@ pub pure fn from_str_common<T: Num Zero One Ord Copy>(`
`678`	`684`	`) -> Option<T> {`
`679`	`685`	`from_str_bytes_common(str::to_bytes(buf), radix, negative,`
`680`	`686`	`fractional, special, exponent, empty_zero)`
`681`		`-}`
	`687`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -75,12 +75,12 @@ fn old_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results) {`
`75`	`75`	`let map = map::HashMap();`
`76`	`76`	`do timed(&mut results.sequential_strings) {`
`77`	`77`	`for uint::range(0, num_keys) \|i\| {`
`78`		`- let s = uint::to_str(i, 10);`
	`78`	`+ let s = uint::to_str(i);`
`79`	`79`	`map.insert(s, i);`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`for uint::range(0, num_keys) \|i\| {`
`83`		`- let s = uint::to_str(i, 10);`
	`83`	`+ let s = uint::to_str(i);`
`84`	`84`	`assert map.get(s) == i;`
`85`	`85`	`}`
`86`	`86`	`}`
`@@ -90,7 +90,7 @@ fn old_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results) {`
`90`	`90`	`let map = map::HashMap();`
`91`	`91`	`do timed(&mut results.random_strings) {`
`92`	`92`	`for uint::range(0, num_keys) \|i\| {`
`93`		`- let s = uint::to_str(rng.next() as uint, 10);`
	`93`	`+ let s = uint::to_str(rng.next() as uint);`
`94`	`94`	`map.insert(s, i);`
`95`	`95`	`}`
`96`	`96`	`}`
`@@ -99,11 +99,11 @@ fn old_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results) {`
`99`	`99`	`{`
`100`	`100`	`let map = map::HashMap();`
`101`	`101`	`for uint::range(0, num_keys) \|i\| {`
`102`		`- map.insert(uint::to_str(i, 10), i);`
	`102`	`+ map.insert(uint::to_str(i), i);`
`103`	`103`	`}`
`104`	`104`	`do timed(&mut results.delete_strings) {`
`105`	`105`	`for uint::range(0, num_keys) \|i\| {`
`106`		`- assert map.remove(uint::to_str(i, 10));`
	`106`	`+ assert map.remove(uint::to_str(i));`
`107`	`107`	`}`
`108`	`108`	`}`
`109`	`109`	`}`
`@@ -151,12 +151,12 @@ fn linear_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results)`
`151`	`151`	`let mut map = LinearMap::new();`
`152`	`152`	`do timed(&mut results.sequential_strings) {`
`153`	`153`	`for uint::range(0, num_keys) \|i\| {`
`154`		`- let s = uint::to_str(i, 10);`
	`154`	`+ let s = uint::to_str(i);`
`155`	`155`	`map.insert(s, i);`
`156`	`156`	`}`
`157`	`157`
`158`	`158`	`for uint::range(0, num_keys) \|i\| {`
`159`		`- let s = uint::to_str(i, 10);`
	`159`	`+ let s = uint::to_str(i);`
`160`	`160`	`assert map.find(&s).unwrap() == &i;`
`161`	`161`	`}`
`162`	`162`	`}`
`@@ -166,7 +166,7 @@ fn linear_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results)`
`166`	`166`	`let mut map = LinearMap::new();`
`167`	`167`	`do timed(&mut results.random_strings) {`
`168`	`168`	`for uint::range(0, num_keys) \|i\| {`
`169`		`- let s = uint::to_str(rng.next() as uint, 10);`
	`169`	`+ let s = uint::to_str(rng.next() as uint);`
`170`	`170`	`map.insert(s, i);`
`171`	`171`	`}`
`172`	`172`	`}`
`@@ -175,11 +175,11 @@ fn linear_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results)`
`175`	`175`	`{`
`176`	`176`	`let mut map = LinearMap::new();`
`177`	`177`	`for uint::range(0, num_keys) \|i\| {`
`178`		`- map.insert(uint::to_str(i, 10), i);`
	`178`	`+ map.insert(uint::to_str(i), i);`
`179`	`179`	`}`
`180`	`180`	`do timed(&mut results.delete_strings) {`
`181`	`181`	`for uint::range(0, num_keys) \|i\| {`
`182`		`- assert map.remove(&uint::to_str(i, 10));`
	`182`	`+ assert map.remove(&uint::to_str(i));`
`183`	`183`	`}`
`184`	`184`	`}`
`185`	`185`	`}`
`@@ -227,12 +227,12 @@ fn tree_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results) {`
`227`	`227`	`let mut map = TreeMap::new();`
`228`	`228`	`do timed(&mut results.sequential_strings) {`
`229`	`229`	`for uint::range(0, num_keys) \|i\| {`
`230`		`- let s = uint::to_str(i, 10);`
	`230`	`+ let s = uint::to_str(i);`
`231`	`231`	`map.insert(s, i);`
`232`	`232`	`}`
`233`	`233`
`234`	`234`	`for uint::range(0, num_keys) \|i\| {`
`235`		`- let s = uint::to_str(i, 10);`
	`235`	`+ let s = uint::to_str(i);`
`236`	`236`	`assert map.find(&s).unwrap() == &i;`
`237`	`237`	`}`
`238`	`238`	`}`
`@@ -242,7 +242,7 @@ fn tree_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results) {`
`242`	`242`	`let mut map = TreeMap::new();`
`243`	`243`	`do timed(&mut results.random_strings) {`
`244`	`244`	`for uint::range(0, num_keys) \|i\| {`
`245`		`- let s = uint::to_str(rng.next() as uint, 10);`
	`245`	`+ let s = uint::to_str(rng.next() as uint);`
`246`	`246`	`map.insert(s, i);`
`247`	`247`	`}`
`248`	`248`	`}`
`@@ -251,11 +251,11 @@ fn tree_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results) {`
`251`	`251`	`{`
`252`	`252`	`let mut map = TreeMap::new();`
`253`	`253`	`for uint::range(0, num_keys) \|i\| {`
`254`		`- map.insert(uint::to_str(i, 10), i);`
	`254`	`+ map.insert(uint::to_str(i), i);`
`255`	`255`	`}`
`256`	`256`	`do timed(&mut results.delete_strings) {`
`257`	`257`	`for uint::range(0, num_keys) \|i\| {`
`258`		`- assert map.remove(&uint::to_str(i, 10));`
	`258`	`+ assert map.remove(&uint::to_str(i));`
`259`	`259`	`}`
`260`	`260`	`}`
`261`	`261`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ fn main() {`
`21`	`21`	`let n = uint::from_str(args[1]).get();`
`22`	`22`
`23`	`23`	`for uint::range(0u, n) \|i\| {`
`24`		`- let x = uint::to_str(i, 10u);`
	`24`	`+ let x = uint::to_str(i);`
`25`	`25`	`log(debug, x);`
`26`	`26`	`}`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,5 +14,5 @@ pub fn main() {`
`14`	`14`
`15`	`15`	`let digits: uint = 10 as uint;`
`16`	`16`
`17`		`- ::core::io::println(float::to_str(f64::sqrt(42.0f64) as float, digits));`
	`17`	`+ ::core::io::println(float::to_str_digits(f64::sqrt(42.0f64) as float, digits));`
`18`	`18`	`}`