Remove lots of numeric traits from the preludes

Num, NumCast, Unsigned, Float, Primitive and Int have been removed.

Author: brendanzab

src/doc/guide-lifetimes.md

@@ -51,6 +51,7 @@ expensive. So we'd like to define a function that takes the points just as
 a reference.
 
 ~~~
+# use std::num::Float;
 # struct Point {x: f64, y: f64}
 # fn sqrt(f: f64) -> f64 { 0.0 }
 fn compute_distance(p1: &Point, p2: &Point) -> f64 {

src/doc/guide-tasks.md

@@ -225,6 +225,7 @@ Here is another example showing how futures allow you to background
 computations. The workload will be distributed on the available cores.
 
 ```{rust}
+# use std::num::Float;
 # use std::sync::Future;
 fn partial_sum(start: uint) -> f64 {
     let mut local_sum = 0f64;
@@ -262,6 +263,7 @@ several computations on a single large vector of floats. Each task needs the
 full vector to perform its duty.
 
 ```{rust}
+use std::num::Float;
 use std::rand;
 use std::sync::Arc;
 

src/libarena/lib.rs

@@ -38,7 +38,7 @@ use std::cmp;
 use std::intrinsics::{TyDesc, get_tydesc};
 use std::intrinsics;
 use std::mem;
-use std::num::UnsignedInt;
+use std::num::{Int, UnsignedInt};
 use std::ptr;
 use std::rc::Rc;
 use std::rt::heap::{allocate, deallocate};

src/libcollections/bit.rs

@@ -22,6 +22,7 @@
 //!
 //! ```
 //! use std::collections::{BitvSet, Bitv};
+//! use std::num::Float;
 //! use std::iter;
 //!
 //! let max_prime = 10000;
@@ -69,6 +70,7 @@ use core::default::Default;
 use core::fmt;
 use core::iter::{Chain, Enumerate, Repeat, Skip, Take};
 use core::iter;
+use core::num::Int;
 use core::slice;
 use core::u32;
 use std::hash;

src/libcollections/enum_set.rs

@@ -15,6 +15,7 @@
 
 use core::prelude::*;
 use core::fmt;
+use core::num::Int;
 
 // FIXME(contentions): implement union family of methods? (general design may be wrong here)
 

src/libcollections/hash/mod.rs

@@ -69,6 +69,7 @@ use alloc::boxed::Box;
 use alloc::rc::Rc;
 use core::intrinsics::TypeId;
 use core::mem;
+use core::num::Int;
 
 use vec::Vec;
 

src/libcollections/vec.rs

@@ -21,7 +21,7 @@ use core::default::Default;
 use core::fmt;
 use core::kinds::marker::{ContravariantLifetime, InvariantType};
 use core::mem;
-use core::num::UnsignedInt;
+use core::num::{Int, UnsignedInt};
 use core::ops;
 use core::ptr;
 use core::raw::Slice as RawSlice;

src/libcore/num/f32.rs

@@ -234,6 +234,8 @@ impl Float for f32 {
     /// The fractional part of the number, satisfying:
     ///
     /// ```rust
+    /// use core::num::Float;
+    ///
     /// let x = 1.65f32;
     /// assert!(x == x.trunc() + x.fract())
     /// ```

src/libcore/num/f64.rs

@@ -240,6 +240,8 @@ impl Float for f64 {
     /// The fractional part of the number, satisfying:
     ///
     /// ```rust
+    /// use core::num::Float;
+    ///
     /// let x = 1.65f64;
     /// assert!(x == x.trunc() + x.fract())
     /// ```

src/libcore/num/mod.rs

@@ -204,6 +204,8 @@ pub trait Int
     /// # Example
     ///
     /// ```rust
+    /// use std::num::Int;
+    ///
     /// let n = 0b01001100u8;
     ///
     /// assert_eq!(n.count_ones(), 3);
@@ -215,6 +217,8 @@ pub trait Int
     /// # Example
     ///
     /// ```rust
+    /// use std::num::Int;
+    ///
     /// let n = 0b01001100u8;
     ///
     /// assert_eq!(n.count_zeros(), 5);
@@ -230,6 +234,8 @@ pub trait Int
     /// # Example
     ///
     /// ```rust
+    /// use std::num::Int;
+    ///
     /// let n = 0b0101000u16;
     ///
     /// assert_eq!(n.leading_zeros(), 10);
@@ -242,6 +248,8 @@ pub trait Int
     /// # Example
     ///
     /// ```rust
+    /// use std::num::Int;
+    ///
     /// let n = 0b0101000u16;
     ///
     /// assert_eq!(n.trailing_zeros(), 3);
@@ -254,6 +262,8 @@ pub trait Int
     /// # Example
     ///
     /// ```rust
+    /// use std::num::Int;
+    ///
     /// let n = 0x0123456789ABCDEFu64;
     /// let m = 0x3456789ABCDEF012u64;
     ///
@@ -267,6 +277,8 @@ pub trait Int
     /// # Example
     ///
     /// ```rust
+    /// use std::num::Int;
+    ///
     /// let n = 0x0123456789ABCDEFu64;
     /// let m = 0xDEF0123456789ABCu64;
     ///
@@ -279,6 +291,8 @@ pub trait Int
     /// # Example
     ///
     /// ```rust
+    /// use std::num::Int;
+    ///
     /// let n = 0x0123456789ABCDEFu64;
     /// let m = 0xEFCDAB8967452301u64;
     ///
@@ -293,6 +307,8 @@ pub trait Int
     /// # Example
     ///
     /// ```rust
+    /// use std::num::Int;
+    ///
     /// let n = 0x0123456789ABCDEFu64;
     ///
     /// if cfg!(target_endian = "big") {
@@ -313,6 +329,8 @@ pub trait Int
     /// # Example
     ///
     /// ```rust
+    /// use std::num::Int;
+    ///
     /// let n = 0x0123456789ABCDEFu64;
     ///
     /// if cfg!(target_endian = "little") {
@@ -333,6 +351,8 @@ pub trait Int
     /// # Example
     ///
     /// ```rust
+    /// use std::num::Int;
+    ///
     /// let n = 0x0123456789ABCDEFu64;
     ///
     /// if cfg!(target_endian = "big") {
@@ -353,6 +373,8 @@ pub trait Int
     /// # Example
     ///
     /// ```rust
+    /// use std::num::Int;
+    ///
     /// let n = 0x0123456789ABCDEFu64;
     ///
     /// if cfg!(target_endian = "little") {

src/libcore/prelude.rs

@@ -51,9 +51,7 @@ pub use cmp::{Ordering, Less, Equal, Greater, Equiv};
 pub use iter::{FromIterator, Extend};
 pub use iter::{Iterator, DoubleEndedIterator, RandomAccessIterator, CloneableIterator};
 pub use iter::{OrdIterator, MutableDoubleEndedIterator, ExactSize};
-pub use num::{Num, NumCast};
-pub use num::{Signed, Unsigned, Float};
-pub use num::{Primitive, Int, ToPrimitive, FromPrimitive};
+pub use num::{Signed, ToPrimitive, FromPrimitive};
 pub use option::{Option, Some, None};
 pub use ptr::RawPtr;
 pub use result::{Result, Ok, Err};

src/libcoretest/iter.rs

@@ -12,7 +12,6 @@ use core::iter::*;
 use core::iter::order::*;
 use core::uint;
 use core::cmp;
-use core::num;
 use core::ops::Slice;
 
 use test::Bencher;
@@ -689,50 +688,6 @@ fn test_double_ended_range() {
 
 #[test]
 fn test_range() {
-    /// A mock type to check Range when ToPrimitive returns None
-    struct Foo;
-
-    impl ToPrimitive for Foo {
-        fn to_i64(&self) -> Option<i64> { None }
-        fn to_u64(&self) -> Option<u64> { None }
-    }
-
-    impl Add<Foo, Foo> for Foo {
-        fn add(&self, _: &Foo) -> Foo {
-            Foo
-        }
-    }
-
-    impl PartialEq for Foo {
-        fn eq(&self, _: &Foo) -> bool {
-            true
-        }
-    }
-
-    impl PartialOrd for Foo {
-        fn partial_cmp(&self, _: &Foo) -> Option<Ordering> {
-            None
-        }
-    }
-
-    impl Clone for Foo {
-        fn clone(&self) -> Foo {
-            Foo
-        }
-    }
-
-    impl Mul<Foo, Foo> for Foo {
-        fn mul(&self, _: &Foo) -> Foo {
-            Foo
-        }
-    }
-
-    impl num::One for Foo {
-        fn one() -> Foo {
-            Foo
-        }
-    }
-
     assert!(range(0i, 5).collect::<Vec<int>>() == vec![0i, 1, 2, 3, 4]);
     assert!(range(-10i, -1).collect::<Vec<int>>() ==
                vec![-10, -9, -8, -7, -6, -5, -4, -3, -2]);
@@ -746,7 +701,6 @@ fn test_range() {
     // this test is only meaningful when sizeof uint < sizeof u64
     assert_eq!(range(uint::MAX - 1, uint::MAX).size_hint(), (1, Some(1)));
     assert_eq!(range(-10i, -1).size_hint(), (9, Some(9)));
-    assert_eq!(range(Foo, Foo).size_hint(), (0, None));
 }
 
 #[test]

src/libcoretest/num/int_macros.rs

@@ -15,6 +15,7 @@ macro_rules! int_module (($T:ty, $T_i:ident) => (
 mod tests {
     use core::$T_i::*;
     use core::int;
+    use core::num::Int;
     use num;
 
     #[test]

src/libcoretest/num/mod.rs

@@ -8,7 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::num::cast;
+use core::cmp::PartialEq;
+use core::fmt::Show;
+use core::num::{NumCast, cast};
+use core::ops::{Add, Sub, Mul, Div, Rem};
 
 mod int_macros;
 mod i8;
@@ -24,7 +27,12 @@ mod u64;
 mod uint;
 
 /// Helper function for testing numeric operations
-pub fn test_num<T: Int + ::std::fmt::Show>(ten: T, two: T) {
+pub fn test_num<T>(ten: T, two: T) where
+    T: PartialEq + NumCast
+     + Add<T, T> + Sub<T, T>
+     + Mul<T, T> + Div<T, T>
+     + Rem<T, T> + Show
+{
     assert_eq!(ten.add(&two),  cast(12i).unwrap());
     assert_eq!(ten.sub(&two),  cast(8i).unwrap());
     assert_eq!(ten.mul(&two),  cast(20i).unwrap());

src/libcoretest/num/uint_macros.rs

@@ -14,6 +14,7 @@ macro_rules! uint_module (($T:ty, $T_i:ident) => (
 #[cfg(test)]
 mod tests {
     use core::$T_i::*;
+    use core::num::Int;
     use num;
 
     #[test]

src/librand/chacha.rs

@@ -11,6 +11,7 @@
 //! The ChaCha random number generator.
 
 use core::prelude::*;
+use core::num::Int;
 
 use {Rng, SeedableRng, Rand};
 

src/librand/distributions/mod.rs

@@ -23,6 +23,7 @@ that do not need to record state.
 #![experimental]
 
 use core::prelude::*;
+use core::num::Int;
 
 use {Rng, Rand};
 

src/librand/distributions/range.rs

@@ -13,6 +13,7 @@
 // this is surprisingly complicated to be both generic & correct
 
 use core::prelude::*;
+use core::num::Int;
 
 use Rng;
 use distributions::{Sample, IndependentSample};
@@ -162,6 +163,7 @@ float_impl! { f64 }
 
 #[cfg(test)]
 mod tests {
+    use std::num::Int;
     use std::prelude::*;
     use distributions::{Sample, IndependentSample};
     use super::Range;

src/librbml/lib.rs

@@ -114,10 +114,11 @@ pub enum Error {
 pub mod reader {
     use std::char;
 
-    use std::mem::transmute;
     use std::int;
-    use std::option::{None, Option, Some};
     use std::io::extensions::u64_from_be_bytes;
+    use std::mem::transmute;
+    use std::num::Int;
+    use std::option::{None, Option, Some};
 
     use serialize;
 

src/librustc/back/lto.rs

@@ -23,6 +23,7 @@ use flate;
 
 use std::iter;
 use std::mem;
+use std::num::Int;
 
 pub fn run(sess: &session::Session, llmod: ModuleRef,
            tm: TargetMachineRef, reachable: &[String]) {

src/librustc/middle/check_match.rs

@@ -21,6 +21,7 @@ use middle::ty;
 use std::fmt;
 use std::iter::AdditiveIterator;
 use std::iter::range_inclusive;
+use std::num::Float;
 use std::slice;
 use syntax::ast::*;
 use syntax::ast_util::walk_pat;

src/librustc/middle/trans/type_of.rs

@@ -21,6 +21,7 @@ use util::ppaux::Repr;
 
 use middle::trans::type_::Type;
 
+use std::num::Int;
 use syntax::abi;
 use syntax::ast;
 

src/librustc_back/sha2.rs

@@ -15,6 +15,7 @@
 #![allow(deprecated)] // to_be32
 
 use std::iter::range_step;
+use std::num::Int;
 use std::slice::bytes::{MutableByteVector, copy_memory};
 use serialize::hex::ToHex;
 
@@ -530,6 +531,7 @@ mod tests {
     use self::rand::isaac::IsaacRng;
     use self::rand::Rng;
     use serialize::hex::FromHex;
+    use std::num::Int;
 
     // A normal addition - no overflow occurs
     #[test]