Auto merge of #24674 - alexcrichton:rollup, r=alexcrichton

19 files changed, 463 insertions, 2203 deletions

diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs
index 72c25c68040..4b75bd5f67e 100644
--- a/src/libcore/fmt/float.rs
+++ b/src/libcore/fmt/float.rs
@@ -11,15 +11,15 @@
 pub use self::ExponentFormat::*;
 pub use self::SignificantDigits::*;
 
-use char::{self, CharExt};
+use prelude::*;
+
+use char;
 use fmt;
-use iter::Iterator;
-use num::{cast, Float, ToPrimitive};
+use num::Float;
 use num::FpCategory as Fp;
-use ops::FnOnce;
-use result::Result::Ok;
-use slice::{self, SliceExt};
-use str::{self, StrExt};
+use ops::{Div, Rem, Mul};
+use slice;
+use str;
 
 /// A flag that specifies whether to use exponential (scientific) notation.
 pub enum ExponentFormat {
@@ -42,6 +42,21 @@ pub enum SignificantDigits {
     DigExact(usize)
 }
 
+#[doc(hidden)]
+pub trait MyFloat: Float + PartialEq + PartialOrd + Div<Output=Self> +
+                   Mul<Output=Self> + Rem<Output=Self> + Copy {
+    fn from_u32(u: u32) -> Self;
+    fn to_i32(&self) -> i32;
+}
+
+macro_rules! doit {
+    ($($t:ident)*) => ($(impl MyFloat for $t {
+        fn from_u32(u: u32) -> $t { u as $t }
+        fn to_i32(&self) -> i32 { *self as i32 }
+    })*)
+}
+doit! { f32 f64 }
+
 /// Converts a float number to its string representation.
 /// This is meant to be a common base implementation for various formatting styles.
 /// The number is assumed to be non-negative, callers use `Formatter::pad_integral`
@@ -63,7 +78,7 @@ pub enum SignificantDigits {
 /// # Panics
 ///
 /// - Panics if `num` is negative.
-pub fn float_to_str_bytes_common<T: Float, U, F>(
+pub fn float_to_str_bytes_common<T: MyFloat, U, F>(
     num: T,
     digits: SignificantDigits,
     exp_format: ExponentFormat,
@@ -72,10 +87,10 @@ pub fn float_to_str_bytes_common<T: Float, U, F>(
 ) -> U where
     F: FnOnce(&str) -> U,
 {
-    let _0: T = Float::zero();
-    let _1: T = Float::one();
+    let _0: T = T::zero();
+    let _1: T = T::one();
     let radix: u32 = 10;
-    let radix_f: T = cast(radix).unwrap();
+    let radix_f = T::from_u32(radix);
 
     assert!(num.is_nan() || num >= _0, "float_to_str_bytes_common: number is negative");
 
@@ -99,7 +114,7 @@ pub fn float_to_str_bytes_common<T: Float, U, F>(
     let (num, exp) = match exp_format {
         ExpDec if num != _0 => {
             let exp = num.log10().floor();
-            (num / radix_f.powf(exp), cast::<T, i32>(exp).unwrap())
+            (num / radix_f.powf(exp), exp.to_i32())
         }
         _ => (num, 0)
     };
@@ -114,7 +129,7 @@ pub fn float_to_str_bytes_common<T: Float, U, F>(
         deccum = deccum / radix_f;
         deccum = deccum.trunc();
 
-        let c = char::from_digit(current_digit.to_isize().unwrap() as u32, radix);
+        let c = char::from_digit(current_digit.to_i32() as u32, radix);
         buf[end] = c.unwrap() as u8;
         end += 1;
 
@@ -158,7 +173,7 @@ pub fn float_to_str_bytes_common<T: Float, U, F>(
 
             let current_digit = deccum.trunc();
 
-            let c = char::from_digit(current_digit.to_isize().unwrap() as u32, radix);
+            let c = char::from_digit(current_digit.to_i32() as u32, radix);
             buf[end] = c.unwrap() as u8;
             end += 1;
 
diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index 80c661b260c..0178b321e88 100644
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -12,21 +12,16 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
+use prelude::*;
+
 use cell::{Cell, RefCell, Ref, RefMut, BorrowState};
-use char::CharExt;
-use clone::Clone;
-use iter::Iterator;
-use marker::{Copy, PhantomData, Sized};
+use marker::PhantomData;
 use mem;
-use num::Float;
-use option::Option;
-use option::Option::{Some, None};
-use result::Result::Ok;
-use ops::{Deref, FnOnce};
+use ops::Deref;
 use result;
-use slice::SliceExt;
+use num::Float;
 use slice;
-use str::{self, StrExt};
+use str;
 use self::rt::v1::Alignment;
 
 pub use self::num::radix;
@@ -83,6 +78,23 @@ pub trait Write {
     #[stable(feature = "rust1", since = "1.0.0")]
     fn write_str(&mut self, s: &str) -> Result;
 
+    /// Writes a `char` into this writer, returning whether the write succeeded.
+    ///
+    /// A single `char` may be encoded as more than one byte.
+    /// This method can only succeed if the entire byte sequence was successfully
+    /// written, and this method will not return until all data has been
+    /// written or an error occurs.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an instance of `FormatError` on error.
+    #[stable(feature = "fmt_write_char", since = "1.1.0")]
+    fn write_char(&mut self, c: char) -> Result {
+        let mut utf_8 = [0u8; 4];
+        let bytes_written = c.encode_utf8(&mut utf_8).unwrap_or(0);
+        self.write_str(unsafe { mem::transmute(&utf_8[..bytes_written]) })
+    }
+
     /// Glue for usage of the `write!` macro with implementers of this trait.
     ///
     /// This method should generally not be invoked manually, but rather through
@@ -912,7 +924,8 @@ impl<'a, T> Pointer for &'a mut T {
 }
 
 // Common code of floating point Debug and Display.
-fn float_to_str_common<T: Float, F>(num: &T, precision: Option<usize>, post: F) -> Result
+fn float_to_str_common<T: float::MyFloat, F>(num: &T, precision: Option<usize>,
+                                             post: F) -> Result
         where F : FnOnce(&str) -> Result {
     let digits = match precision {
         Some(i) => float::DigExact(i),
@@ -950,8 +963,6 @@ macro_rules! floating { ($ty:ident) => {
     #[stable(feature = "rust1", since = "1.0.0")]
     impl LowerExp for $ty {
         fn fmt(&self, fmt: &mut Formatter) -> Result {
-            use num::Float;
-
             let digits = match fmt.precision {
                 Some(i) => float::DigExact(i),
                 None => float::DigMax(6),
@@ -969,8 +980,6 @@ macro_rules! floating { ($ty:ident) => {
     #[stable(feature = "rust1", since = "1.0.0")]
     impl UpperExp for $ty {
         fn fmt(&self, fmt: &mut Formatter) -> Result {
-            use num::Float;
-
             let digits = match fmt.precision {
                 Some(i) => float::DigExact(i),
                 None => float::DigMax(6),
diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs
index 76c975902aa..122fffc5959 100644
--- a/src/libcore/fmt/num.rs
+++ b/src/libcore/fmt/num.rs
@@ -14,12 +14,28 @@
 
 #![allow(unsigned_negation)]
 
+use prelude::*;
+
 use fmt;
-use iter::Iterator;
-use num::{Int, cast};
-use slice::SliceExt;
+use num::Zero;
+use ops::{Div, Rem, Sub};
 use str;
 
+#[doc(hidden)]
+trait Int: Zero + PartialEq + PartialOrd + Div<Output=Self> + Rem<Output=Self> +
+           Sub<Output=Self> + Copy {
+    fn from_u8(u: u8) -> Self;
+    fn to_u8(&self) -> u8;
+}
+
+macro_rules! doit {
+    ($($t:ident)*) => ($(impl Int for $t {
+        fn from_u8(u: u8) -> $t { u as $t }
+        fn to_u8(&self) -> u8 { *self as u8 }
+    })*)
+}
+doit! { i8 i16 i32 i64 isize u8 u16 u32 u64 usize }
+
 /// A type that represents a specific radix
 #[doc(hidden)]
 trait GenericRadix {
@@ -33,33 +49,32 @@ trait GenericRadix {
     fn digit(&self, x: u8) -> u8;
 
     /// Format an integer using the radix using a formatter.
-    #[allow(deprecated)] // Int
     fn fmt_int<T: Int>(&self, mut x: T, f: &mut fmt::Formatter) -> fmt::Result {
         // The radix can be as low as 2, so we need a buffer of at least 64
         // characters for a base 2 number.
-        let zero = Int::zero();
+        let zero = T::zero();
         let is_positive = x >= zero;
         let mut buf = [0; 64];
         let mut curr = buf.len();
-        let base = cast(self.base()).unwrap();
+        let base = T::from_u8(self.base());
         if is_positive {
             // Accumulate each digit of the number from the least significant
             // to the most significant figure.
             for byte in buf.iter_mut().rev() {
-                let n = x % base;                         // Get the current place value.
-                x = x / base;                             // Deaccumulate the number.
-                *byte = self.digit(cast(n).unwrap());     // Store the digit in the buffer.
+                let n = x % base;              // Get the current place value.
+                x = x / base;                  // Deaccumulate the number.
+                *byte = self.digit(n.to_u8()); // Store the digit in the buffer.
                 curr -= 1;
-                if x == zero { break };                   // No more digits left to accumulate.
+                if x == zero { break };        // No more digits left to accumulate.
             }
         } else {
             // Do the same as above, but accounting for two's complement.
             for byte in buf.iter_mut().rev() {
-                let n = zero - (x % base);                // Get the current place value.
-                x = x / base;                             // Deaccumulate the number.
-                *byte = self.digit(cast(n).unwrap());     // Store the digit in the buffer.
+                let n = zero - (x % base);     // Get the current place value.
+                x = x / base;                  // Deaccumulate the number.
+                *byte = self.digit(n.to_u8()); // Store the digit in the buffer.
                 curr -= 1;
-                if x == zero { break };                   // No more digits left to accumulate.
+                if x == zero { break };        // No more digits left to accumulate.
             }
         }
         let buf = unsafe { str::from_utf8_unchecked(&buf[curr..]) };
diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs
index 553e0c0dfe6..e848a44e01c 100644
--- a/src/libcore/hash/mod.rs
+++ b/src/libcore/hash/mod.rs
@@ -62,7 +62,6 @@
 
 use prelude::*;
 
-use default::Default;
 use mem;
 
 pub use self::sip::SipHasher;
diff --git a/src/libcore/hash/sip.rs b/src/libcore/hash/sip.rs
index 65f790d5d43..be419e2cdad 100644
--- a/src/libcore/hash/sip.rs
+++ b/src/libcore/hash/sip.rs
@@ -13,7 +13,6 @@
 #![allow(deprecated)] // until the next snapshot for inherent wrapping ops
 
 use prelude::*;
-use default::Default;
 use super::Hasher;
 
 /// An implementation of SipHash 2-4.
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index 24ef8a6e01a..233ed018119 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -64,7 +64,7 @@ use cmp::{Ord, PartialOrd, PartialEq};
 use default::Default;
 use marker;
 use mem;
-use num::{Int, Zero, One};
+use num::{Zero, One};
 use ops::{self, Add, Sub, FnMut, Mul, RangeFrom};
 use option::Option::{self, Some, None};
 use marker::Sized;
@@ -2327,9 +2327,8 @@ impl<I: RandomAccessIterator, F> RandomAccessIterator for Inspect<I, F>
 /// An iterator that yields sequential Fibonacci numbers, and stops on overflow.
 ///
 /// ```
-/// # #![feature(core)]
+/// #![feature(core)]
 /// use std::iter::Unfold;
-/// use std::num::Int; // For `.checked_add()`
 ///
 /// // This iterator will yield up to the last Fibonacci number before the max
 /// // value of `u32`. You can simply change `u32` to `u64` in this line if
@@ -2647,80 +2646,6 @@ impl<A: Step + Zero + Clone> Iterator for StepBy<A, ops::Range<A>> {
     }
 }
 
-/// An iterator over the range [start, stop] by `step`. It handles overflow by stopping.
-#[derive(Clone)]
-#[unstable(feature = "core",
-           reason = "likely to be replaced by range notation and adapters")]
-pub struct RangeStepInclusive<A> {
-    state: A,
-    stop: A,
-    step: A,
-    rev: bool,
-    done: bool,
-}
-
-/// Returns an iterator over the range [start, stop] by `step`.
-///
-/// It handles overflow by stopping.
-///
-/// # Examples
-///
-/// ```
-/// # #![feature(core)]
-/// use std::iter::range_step_inclusive;
-///
-/// for i in range_step_inclusive(0, 10, 2) {
-///     println!("{}", i);
-/// }
-/// ```
-///
-/// This prints:
-///
-/// ```text
-/// 0
-/// 2
-/// 4
-/// 6
-/// 8
-/// 10
-/// ```
-#[inline]
-#[unstable(feature = "core",
-           reason = "likely to be replaced by range notation and adapters")]
-#[allow(deprecated)]
-pub fn range_step_inclusive<A: Int>(start: A, stop: A, step: A) -> RangeStepInclusive<A> {
-    let rev = step < Int::zero();
-    RangeStepInclusive {
-        state: start,
-        stop: stop,
-        step: step,
-        rev: rev,
-        done: false,
-    }
-}
-
-#[unstable(feature = "core",
-           reason = "likely to be replaced by range notation and adapters")]
-#[allow(deprecated)]
-impl<A: Int> Iterator for RangeStepInclusive<A> {
-    type Item = A;
-
-    #[inline]
-    fn next(&mut self) -> Option<A> {
-        if !self.done && ((self.rev && self.state >= self.stop) ||
-                          (!self.rev && self.state <= self.stop)) {
-            let result = self.state;
-            match self.state.checked_add(self.step) {
-                Some(x) => self.state = x,
-                None => self.done = true
-            }
-            Some(result)
-        } else {
-            None
-        }
-    }
-}
-
 macro_rules! range_exact_iter_impl {
     ($($t:ty)*) => ($(
         #[stable(feature = "rust1", since = "1.0.0")]
diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs
index 164d3e49385..249f0a0c389 100644
--- a/src/libcore/lib.rs
+++ b/src/libcore/lib.rs
@@ -108,6 +108,7 @@ mod uint_macros;
 #[path = "num/f32.rs"]   pub mod f32;
 #[path = "num/f64.rs"]   pub mod f64;
 
+#[macro_use]
 pub mod num;
 
 /* The libcore prelude, not as all-encompassing as the libstd prelude */
diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs
index d6a7126a883..fdabdbc5ed4 100644
--- a/src/libcore/marker.rs
+++ b/src/libcore/marker.rs
@@ -35,7 +35,16 @@ use hash::Hasher;
 #[stable(feature = "rust1", since = "1.0.0")]
 #[lang="send"]
 #[rustc_on_unimplemented = "`{Self}` cannot be sent between threads safely"]
-#[allow(deprecated)]
+#[cfg(not(stage0))]
+pub unsafe trait Send {
+    // empty.
+}
+
+/// Types able to be transferred across thread boundaries.
+#[stable(feature = "rust1", since = "1.0.0")]
+#[lang="send"]
+#[rustc_on_unimplemented = "`{Self}` cannot be sent between threads safely"]
+#[cfg(stage0)]
 pub unsafe trait Send : MarkerTrait {
     // empty.
 }
@@ -51,7 +60,17 @@ impl !Send for Managed { }
 #[lang="sized"]
 #[rustc_on_unimplemented = "`{Self}` does not have a constant size known at compile-time"]
 #[fundamental] // for Default, for example, which requires that `[T]: !Default` be evaluatable
-#[allow(deprecated)]
+#[cfg(not(stage0))]
+pub trait Sized {
+    // Empty.
+}
+
+/// Types with a constant size known at compile-time.
+#[stable(feature = "rust1", since = "1.0.0")]
+#[lang="sized"]
+#[rustc_on_unimplemented = "`{Self}` does not have a constant size known at compile-time"]
+#[fundamental] // for Default, for example, which requires that `[T]: !Default` be evaluatable
+#[cfg(stage0)]
 pub trait Sized : MarkerTrait {
     // Empty.
 }
@@ -199,13 +218,23 @@ pub trait Copy : Clone {
 /// the `sync` crate do ensure that any mutation cannot cause data
 /// races.  Hence these types are `Sync`.
 ///
-/// Any types with interior mutability must also use the `std::cell::UnsafeCell` wrapper around the
-/// value(s) which can be mutated when behind a `&` reference; not doing this is undefined
-/// behaviour (for example, `transmute`-ing from `&T` to `&mut T` is illegal).
+/// Any types with interior mutability must also use the `std::cell::UnsafeCell`
+/// wrapper around the value(s) which can be mutated when behind a `&`
+/// reference; not doing this is undefined behaviour (for example,
+/// `transmute`-ing from `&T` to `&mut T` is illegal).
+#[cfg(not(stage0))]
+#[stable(feature = "rust1", since = "1.0.0")]
+#[lang="sync"]
+#[rustc_on_unimplemented = "`{Self}` cannot be shared between threads safely"]
+pub unsafe trait Sync {
+    // Empty
+}
+
+/// dox
+#[cfg(stage0)]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[lang="sync"]
 #[rustc_on_unimplemented = "`{Self}` cannot be shared between threads safely"]
-#[allow(deprecated)]
 pub unsafe trait Sync : MarkerTrait {
     // Empty
 }
@@ -272,42 +301,20 @@ macro_rules! impls{
         )
 }
 
-/// `MarkerTrait` is deprecated and no longer needed.
+/// dox
 #[stable(feature = "rust1", since = "1.0.0")]
-#[deprecated(since = "1.0.0", reason = "No longer needed")]
-#[allow(deprecated)]
 #[cfg(stage0)]
 pub trait MarkerTrait : PhantomFn<Self,Self> { }
 
-/// `MarkerTrait` is deprecated and no longer needed.
-#[stable(feature = "rust1", since = "1.0.0")]
-#[deprecated(since = "1.0.0", reason = "No longer needed")]
-#[allow(deprecated)]
-#[cfg(not(stage0))]
-pub trait MarkerTrait { }
-
-#[allow(deprecated)]
-impl<T:?Sized> MarkerTrait for T { }
+#[cfg(stage0)]
+impl<T: ?Sized> MarkerTrait for T {}
 
-/// `PhantomFn` is a deprecated marker trait that is no longer needed.
+/// dox
 #[lang="phantom_fn"]
-#[stable(feature = "rust1", since = "1.0.0")]
-#[deprecated(since = "1.0.0", reason = "No longer needed")]
 #[cfg(stage0)]
 pub trait PhantomFn<A:?Sized,R:?Sized=()> {
 }
 
-/// `PhantomFn` is a deprecated marker trait that is no longer needed.
-#[stable(feature = "rust1", since = "1.0.0")]
-#[deprecated(since = "1.0.0", reason = "No longer needed")]
-#[cfg(not(stage0))]
-pub trait PhantomFn<A:?Sized,R:?Sized=()> {
-}
-
-#[allow(deprecated)]
-#[cfg(not(stage0))]
-impl<A:?Sized,R:?Sized,T:?Sized> PhantomFn<A,R> for T { }
-
 /// `PhantomData<T>` allows you to describe that a type acts as if it stores a value of type `T`,
 /// even though it does not. This allows you to inform the compiler about certain safety properties
 /// of your code.
@@ -454,8 +461,14 @@ mod impls {
 #[rustc_reflect_like]
 #[unstable(feature = "core", reason = "requires RFC and more experience")]
 #[allow(deprecated)]
-pub trait Reflect : MarkerTrait {
-}
+#[cfg(not(stage0))]
+pub trait Reflect {}
+
+/// dox
+#[rustc_reflect_like]
+#[unstable(feature = "core", reason = "requires RFC and more experience")]
+#[cfg(stage0)]
+pub trait Reflect: MarkerTrait {}
 
 impl Reflect for .. { }
 
diff --git a/src/libcore/nonzero.rs b/src/libcore/nonzero.rs
index db2d1b2f1fd..9ea44c39fe9 100644
--- a/src/libcore/nonzero.rs
+++ b/src/libcore/nonzero.rs
@@ -10,12 +10,17 @@
 
 //! Exposes the NonZero lang item which provides optimization hints.
 
-use marker::{Sized, MarkerTrait};
+use marker::Sized;
 use ops::Deref;
+#[cfg(stage0)] use marker::MarkerTrait;
 
 /// Unsafe trait to indicate what types are usable with the NonZero struct
-#[allow(deprecated)]
-pub unsafe trait Zeroable : MarkerTrait {}
+#[cfg(not(stage0))]
+pub unsafe trait Zeroable {}
+
+/// Unsafe trait to indicate what types are usable with the NonZero struct
+#[cfg(stage0)]
+pub unsafe trait Zeroable: MarkerTrait {}
 
 unsafe impl<T:?Sized> Zeroable for *const T {}
 unsafe impl<T:?Sized> Zeroable for *mut T {}
diff --git a/src/libcore/num/f32.rs b/src/libcore/num/f32.rs
index 12b45a766b6..50dd3f1661a 100644
--- a/src/libcore/num/f32.rs
+++ b/src/libcore/num/f32.rs
@@ -16,11 +16,12 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
+use prelude::*;
+
 use intrinsics;
 use mem;
-use num::Float;
+use num::{Float, ParseFloatError};
 use num::FpCategory as Fp;
-use option::Option;
 
 #[stable(feature = "rust1", since = "1.0.0")]
 pub const RADIX: u32 = 2;
@@ -35,19 +36,6 @@ pub const EPSILON: f32 = 1.19209290e-07_f32;
 
 /// Smallest finite f32 value
 #[stable(feature = "rust1", since = "1.0.0")]
-#[deprecated(since = "1.0.0", reason = "use `std::f32::MIN`")]
-pub const MIN_VALUE: f32 = -3.40282347e+38_f32;
-/// Smallest positive, normalized f32 value
-#[stable(feature = "rust1", since = "1.0.0")]
-#[deprecated(since = "1.0.0", reason = "use `std::f32::MIN_POSITIVE`")]
-pub const MIN_POS_VALUE: f32 = 1.17549435e-38_f32;
-/// Largest finite f32 value
-#[stable(feature = "rust1", since = "1.0.0")]
-#[deprecated(since = "1.0.0", reason = "use `std::f32::MAX`")]
-pub const MAX_VALUE: f32 = 3.40282347e+38_f32;
-
-/// Smallest finite f32 value
-#[stable(feature = "rust1", since = "1.0.0")]
 pub const MIN: f32 = -3.40282347e+38_f32;
 /// Smallest positive, normalized f32 value
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -118,26 +106,14 @@ pub mod consts {
     #[stable(feature = "rust1", since = "1.0.0")]
     pub const FRAC_2_SQRT_PI: f32 = 1.12837916709551257389615890312154517_f32;
 
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[deprecated(since = "1.0.0", reason = "renamed to FRAC_2_SQRT_PI")]
-    pub const FRAC_2_SQRTPI: f32 = 1.12837916709551257389615890312154517_f32;
-
     /// sqrt(2.0)
     #[stable(feature = "rust1", since = "1.0.0")]
     pub const SQRT_2: f32 = 1.41421356237309504880168872420969808_f32;
 
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[deprecated(since = "1.0.0", reason = "renamed to SQRT_2")]
-    pub const SQRT2: f32 = 1.41421356237309504880168872420969808_f32;
-
     /// 1.0/sqrt(2.0)
     #[stable(feature = "rust1", since = "1.0.0")]
     pub const FRAC_1_SQRT_2: f32 = 0.707106781186547524400844362104849039_f32;
 
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[deprecated(since = "1.0.0", reason = "renamed to FRAC_1_SQRT_2")]
-    pub const FRAC_1_SQRT2: f32 = 0.707106781186547524400844362104849039_f32;
-
     /// Euler's number
     #[stable(feature = "rust1", since = "1.0.0")]
     pub const E: f32 = 2.71828182845904523536028747135266250_f32;
@@ -179,6 +155,8 @@ impl Float for f32 {
     #[inline]
     fn one() -> f32 { 1.0 }
 
+    from_str_radix_float_impl! { f32 }
+
     /// Returns `true` if the number is NaN.
     #[inline]
     fn is_nan(self) -> bool { self != self }
@@ -218,56 +196,6 @@ impl Float for f32 {
         }
     }
 
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0")]
-    fn mantissa_digits(_: Option<f32>) -> usize { MANTISSA_DIGITS as usize }
-
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0")]
-    fn digits(_: Option<f32>) -> usize { DIGITS as usize }
-
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0")]
-    fn epsilon() -> f32 { EPSILON }
-
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0")]
-    fn min_exp(_: Option<f32>) -> isize { MIN_EXP as isize }
-
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0")]
-    fn max_exp(_: Option<f32>) -> isize { MAX_EXP as isize }
-
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0")]
-    fn min_10_exp(_: Option<f32>) -> isize { MIN_10_EXP as isize }
-
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0")]
-    fn max_10_exp(_: Option<f32>) -> isize { MAX_10_EXP as isize }
-
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0")]
-    fn min_value() -> f32 { MIN }
-
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0")]
-    fn min_pos_value(_: Option<f32>) -> f32 { MIN_POSITIVE }
-
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0")]
-    fn max_value() -> f32 { MAX }
-
     /// Returns the mantissa, exponent and sign as integers.
     fn integer_decode(self) -> (u64, i16, i8) {
         let bits: u32 = unsafe { mem::transmute(self) };
@@ -310,9 +238,6 @@ impl Float for f32 {
     /// The fractional part of the number, satisfying:
     ///
     /// ```
-    /// # #![feature(core)]
-    /// use std::num::Float;
-    ///
     /// let x = 1.65f32;
     /// assert!(x == x.trunc() + x.fract())
     /// ```
diff --git a/src/libcore/num/f64.rs b/src/libcore/num/f64.rs
index 058acedd9c9..62b566e7eb4 100644
--- a/src/libcore/num/f64.rs
+++ b/src/libcore/num/f64.rs
@@ -16,11 +16,12 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
+use prelude::*;
+
 use intrinsics;
 use mem;
-use num::Float;
 use num::FpCategory as Fp;
-use option::Option;
+use num::{Float, ParseFloatError};
 
 #[stable(feature = "rust1", since = "1.0.0")]
 pub const RADIX: u32 = 2;
@@ -35,19 +36,6 @@ pub const EPSILON: f64 = 2.2204460492503131e-16_f64;
 
 /// Smallest finite f64 value
 #[stable(feature = "rust1", since = "1.0.0")]
-#[deprecated(since = "1.0.0", reason = "use `std::f64::MIN`")]
-pub const MIN_VALUE: f64 = -1.7976931348623157e+308_f64;
-/// Smallest positive, normalized f64 value
-#[stable(feature = "rust1", since = "1.0.0")]
-#[deprecated(since = "1.0.0", reason = "use `std::f64::MIN_POSITIVE`")]
-pub const MIN_POS_VALUE: f64 = 2.2250738585072014e-308_f64;
-/// Largest finite f64 value
-#[stable(feature = "rust1", since = "1.0.0")]
-#[deprecated(since = "1.0.0", reason = "use `std::f64::MAX`")]
-pub const MAX_VALUE: f64 = 1.7976931348623157e+308_f64;
-
-/// Smallest finite f64 value
-#[stable(feature = "rust1", since = "1.0.0")]
 pub const MIN: f64 = -1.7976931348623157e+308_f64;
 /// Smallest positive, normalized f64 value
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -118,26 +106,14 @@ pub mod consts {
     #[stable(feature = "rust1", since = "1.0.0")]
     pub const FRAC_2_SQRT_PI: f64 = 1.12837916709551257389615890312154517_f64;
 
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[deprecated(since = "1.0.0", reason = "renamed to FRAC_2_SQRT_PI")]
-    pub const FRAC_2_SQRTPI: f64 = 1.12837916709551257389615890312154517_f64;
-
     /// sqrt(2.0)
     #[stable(feature = "rust1", since = "1.0.0")]
     pub const SQRT_2: f64 = 1.41421356237309504880168872420969808_f64;
 
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[deprecated(since = "1.0.0", reason = "renamed to SQRT_2")]
-    pub const SQRT2: f64 = 1.41421356237309504880168872420969808_f64;
-
     /// 1.0/sqrt(2.0)
     #[stable(feature = "rust1", since = "1.0.0")]
     pub const FRAC_1_SQRT_2: f64 = 0.707106781186547524400844362104849039_f64;
 
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[deprecated(since = "1.0.0", reason = "renamed to FRAC_1_SQRT_2")]
-    pub const FRAC_1_SQRT2: f64 = 0.707106781186547524400844362104849039_f64;
-
     /// Euler's number
     #[stable(feature = "rust1", since = "1.0.0")]
     pub const E: f64 = 2.71828182845904523536028747135266250_f64;
@@ -179,6 +155,8 @@ impl Float for f64 {
     #[inline]
     fn one() -> f64 { 1.0 }
 
+    from_str_radix_float_impl! { f64 }
+
     /// Returns `true` if the number is NaN.
     #[inline]
     fn is_nan(self) -> bool { self != self }
@@ -218,56 +196,6 @@ impl Float for f64 {
         }
     }
 
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0")]
-    fn mantissa_digits(_: Option<f64>) -> usize { MANTISSA_DIGITS as usize }
-
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0")]
-    fn digits(_: Option<f64>) -> usize { DIGITS as usize }
-
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0")]
-    fn epsilon() -> f64 { EPSILON }
-
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0")]
-    fn min_exp(_: Option<f64>) -> isize { MIN_EXP as isize }
-
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0")]
-    fn max_exp(_: Option<f64>) -> isize { MAX_EXP as isize }
-
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0")]
-    fn min_10_exp(_: Option<f64>) -> isize { MIN_10_EXP as isize }
-
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0")]
-    fn max_10_exp(_: Option<f64>) -> isize { MAX_10_EXP as isize }
-
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0")]
-    fn min_value() -> f64 { MIN }
-
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0")]
-    fn min_pos_value(_: Option<f64>) -> f64 { MIN_POSITIVE }
-
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0")]
-    fn max_value() -> f64 { MAX }
-
     /// Returns the mantissa, exponent and sign as integers.
     fn integer_decode(self) -> (u64, i16, i8) {
         let bits: u64 = unsafe { mem::transmute(self) };
@@ -310,9 +238,6 @@ impl Float for f64 {
     /// The fractional part of the number, satisfying:
     ///
     /// ```
-    /// # #![feature(core)]
-    /// use std::num::Float;
-    ///
     /// let x = 1.65f64;
     /// assert!(x == x.trunc() + x.fract())
     /// ```
diff --git a/src/libcore/num/float_macros.rs b/src/libcore/num/float_macros.rs
index b3adef53dab..5ee0dc19f9b 100644
--- a/src/libcore/num/float_macros.rs
+++ b/src/libcore/num/float_macros.rs
@@ -18,3 +18,145 @@ macro_rules! assert_approx_eq {
                 "{} is not approximately equal to {}", *a, *b);
     })
 }
+
+macro_rules! from_str_radix_float_impl {
+    ($T:ty) => {
+        fn from_str_radix(src: &str, radix: u32)
+                          -> Result<$T, ParseFloatError> {
+            use num::FloatErrorKind::*;
+            use num::ParseFloatError as PFE;
+
+            // Special values
+            match src {
+                "inf"   => return Ok(Float::infinity()),
+                "-inf"  => return Ok(Float::neg_infinity()),
+                "NaN"   => return Ok(Float::nan()),
+                _       => {},
+            }
+
+            let (is_positive, src) =  match src.slice_shift_char() {
+                None             => return Err(PFE { kind: Empty }),
+                Some(('-', ""))  => return Err(PFE { kind: Empty }),
+                Some(('-', src)) => (false, src),
+                Some((_, _))     => (true,  src),
+            };
+
+            // The significand to accumulate
+            let mut sig = if is_positive { 0.0 } else { -0.0 };
+            // Necessary to detect overflow
+            let mut prev_sig = sig;
+            let mut cs = src.chars().enumerate();
+            // Exponent prefix and exponent index offset
+            let mut exp_info = None::<(char, usize)>;
+
+            // Parse the integer part of the significand
+            for (i, c) in cs.by_ref() {
+                match c.to_digit(radix) {
+                    Some(digit) => {
+                        // shift significand one digit left
+                        sig = sig * (radix as $T);
+
+                        // add/subtract current digit depending on sign
+                        if is_positive {
+                            sig = sig + ((digit as isize) as $T);
+                        } else {
+                            sig = sig - ((digit as isize) as $T);
+                        }
+
+                        // Detect overflow by comparing to last value, except
+                        // if we've not seen any non-zero digits.
+                        if prev_sig != 0.0 {
+                            if is_positive && sig <= prev_sig
+                                { return Ok(Float::infinity()); }
+                            if !is_positive && sig >= prev_sig
+                                { return Ok(Float::neg_infinity()); }
+
+                            // Detect overflow by reversing the shift-and-add process
+                            if is_positive && (prev_sig != (sig - digit as $T) / radix as $T)
+                                { return Ok(Float::infinity()); }
+                            if !is_positive && (prev_sig != (sig + digit as $T) / radix as $T)
+                                { return Ok(Float::neg_infinity()); }
+                        }
+                        prev_sig = sig;
+                    },
+                    None => match c {
+                        'e' | 'E' | 'p' | 'P' => {
+                            exp_info = Some((c, i + 1));
+                            break;  // start of exponent
+                        },
+                        '.' => {
+                            break;  // start of fractional part
+                        },
+                        _ => {
+                            return Err(PFE { kind: Invalid });
+                        },
+                    },
+                }
+            }
+
+            // If we are not yet at the exponent parse the fractional
+            // part of the significand
+            if exp_info.is_none() {
+                let mut power = 1.0;
+                for (i, c) in cs.by_ref() {
+                    match c.to_digit(radix) {
+                        Some(digit) => {
+                            // Decrease power one order of magnitude
+                            power = power / (radix as $T);
+                            // add/subtract current digit depending on sign
+                            sig = if is_positive {
+                                sig + (digit as $T) * power
+                            } else {
+                                sig - (digit as $T) * power
+                            };
+                            // Detect overflow by comparing to last value
+                            if is_positive && sig < prev_sig
+                                { return Ok(Float::infinity()); }
+                            if !is_positive && sig > prev_sig
+                                { return Ok(Float::neg_infinity()); }
+                            prev_sig = sig;
+                        },
+                        None => match c {
+                            'e' | 'E' | 'p' | 'P' => {
+                                exp_info = Some((c, i + 1));
+                                break; // start of exponent
+                            },
+                            _ => {
+                                return Err(PFE { kind: Invalid });
+                            },
+                        },
+                    }
+                }
+            }
+
+            // Parse and calculate the exponent
+            let exp = match exp_info {
+                Some((c, offset)) => {
+                    let base = match c {
+                        'E' | 'e' if radix == 10 => 10.0,
+                        'P' | 'p' if radix == 16 => 2.0,
+                        _ => return Err(PFE { kind: Invalid }),
+                    };
+
+                    // Parse the exponent as decimal integer
+                    let src = &src[offset..];
+                    let (is_positive, exp) = match src.slice_shift_char() {
+                        Some(('-', src)) => (false, src.parse::<usize>()),
+                        Some(('+', src)) => (true,  src.parse::<usize>()),
+                        Some((_, _))     => (true,  src.parse::<usize>()),
+                        None             => return Err(PFE { kind: Invalid }),
+                    };
+
+                    match (is_positive, exp) {
+                        (true,  Ok(exp)) => base.powi(exp as i32),
+                        (false, Ok(exp)) => 1.0 / base.powi(exp as i32),
+                        (_, Err(_))      => return Err(PFE { kind: Invalid }),
+                    }
+                },
+                None => 1.0, // no exponent
+            };
+
+            Ok(sig * exp)
+        }
+    }
+}
diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs
index bcfdcfcd5e6..44d5333ce1f 100644
--- a/src/libcore/num/mod.rs
+++ b/src/libcore/num/mod.rs
@@ -13,18 +13,14 @@
 #![stable(feature = "rust1", since = "1.0.0")]
 #![allow(missing_docs)]
 
-use self::wrapping::{OverflowingOps, WrappingOps};
+use self::wrapping::OverflowingOps;
 
 use char::CharExt;
-use clone::Clone;
-use cmp::{PartialEq, Eq, PartialOrd, Ord};
+use cmp::{Eq, PartialOrd};
 use fmt;
 use intrinsics;
-use iter::Iterator;
 use marker::Copy;
 use mem::size_of;
-use ops::{Add, Sub, Mul, Div, Rem, Neg};
-use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr};
 use option::Option::{self, Some, None};
 use result::Result::{self, Ok, Err};
 use str::{FromStr, StrExt};
@@ -98,407 +94,6 @@ macro_rules! zero_one_impl_float {
 }
 zero_one_impl_float! { f32 f64 }
 
-/// A built-in signed or unsigned integer.
-#[stable(feature = "rust1", since = "1.0.0")]
-#[deprecated(since = "1.0.0",
-             reason = "replaced by inherent methods; for generics, use rust-lang/num")]
-#[allow(deprecated)]
-pub trait Int
-    : Copy + Clone
-    + NumCast
-    + PartialOrd + Ord
-    + PartialEq + Eq
-    + Add<Output=Self>
-    + Sub<Output=Self>
-    + Mul<Output=Self>
-    + Div<Output=Self>
-    + Rem<Output=Self>
-    + Not<Output=Self>
-    + BitAnd<Output=Self>
-    + BitOr<Output=Self>
-    + BitXor<Output=Self>
-    + Shl<usize, Output=Self>
-    + Shr<usize, Output=Self>
-    + WrappingOps
-    + OverflowingOps
-{
-    /// Returns the `0` value of this integer type.
-    // FIXME (#5527): Should be an associated constant
-    #[unstable(feature = "core",
-               reason = "unsure about its place in the world")]
-    fn zero() -> Self;
-
-    /// Returns the `1` value of this integer type.
-    // FIXME (#5527): Should be an associated constant
-    #[unstable(feature = "core",
-               reason = "unsure about its place in the world")]
-    fn one() -> Self;
-
-    /// Returns the smallest value that can be represented by this integer type.
-    // FIXME (#5527): Should be and associated constant
-    #[unstable(feature = "core",
-               reason = "unsure about its place in the world")]
-    fn min_value() -> Self;
-
-    /// Returns the largest value that can be represented by this integer type.
-    // FIXME (#5527): Should be and associated constant
-    #[unstable(feature = "core",
-               reason = "unsure about its place in the world")]
-    fn max_value() -> Self;
-
-    /// Returns the number of ones in the binary representation of `self`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(core)]
-    /// use std::num::Int;
-    ///
-    /// let n = 0b01001100u8;
-    ///
-    /// assert_eq!(n.count_ones(), 3);
-    /// ```
-    #[unstable(feature = "core",
-               reason = "pending integer conventions")]
-    fn count_ones(self) -> u32;
-
-    /// Returns the number of zeros in the binary representation of `self`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(core)]
-    /// use std::num::Int;
-    ///
-    /// let n = 0b01001100u8;
-    ///
-    /// assert_eq!(n.count_zeros(), 5);
-    /// ```
-    #[unstable(feature = "core",
-               reason = "pending integer conventions")]
-    #[inline]
-    fn count_zeros(self) -> u32 {
-        (!self).count_ones()
-    }
-
-    /// Returns the number of leading zeros in the binary representation
-    /// of `self`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(core)]
-    /// use std::num::Int;
-    ///
-    /// let n = 0b0101000u16;
-    ///
-    /// assert_eq!(n.leading_zeros(), 10);
-    /// ```
-    #[unstable(feature = "core",
-               reason = "pending integer conventions")]
-    fn leading_zeros(self) -> u32;
-
-    /// Returns the number of trailing zeros in the binary representation
-    /// of `self`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(core)]
-    /// use std::num::Int;
-    ///
-    /// let n = 0b0101000u16;
-    ///
-    /// assert_eq!(n.trailing_zeros(), 3);
-    /// ```
-    #[unstable(feature = "core",
-               reason = "pending integer conventions")]
-    fn trailing_zeros(self) -> u32;
-
-    /// Shifts the bits to the left by a specified amount, `n`, wrapping
-    /// the truncated bits to the end of the resulting integer.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(core)]
-    /// use std::num::Int;
-    ///
-    /// let n = 0x0123456789ABCDEFu64;
-    /// let m = 0x3456789ABCDEF012u64;
-    ///
-    /// assert_eq!(n.rotate_left(12), m);
-    /// ```
-    #[unstable(feature = "core",
-               reason = "pending integer conventions")]
-    fn rotate_left(self, n: u32) -> Self;
-
-    /// Shifts the bits to the right by a specified amount, `n`, wrapping
-    /// the truncated bits to the beginning of the resulting integer.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(core)]
-    /// use std::num::Int;
-    ///
-    /// let n = 0x0123456789ABCDEFu64;
-    /// let m = 0xDEF0123456789ABCu64;
-    ///
-    /// assert_eq!(n.rotate_right(12), m);
-    /// ```
-    #[unstable(feature = "core",
-               reason = "pending integer conventions")]
-    fn rotate_right(self, n: u32) -> Self;
-
-    /// Reverses the byte order of the integer.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::num::Int;
-    ///
-    /// let n = 0x0123456789ABCDEFu64;
-    /// let m = 0xEFCDAB8967452301u64;
-    ///
-    /// assert_eq!(n.swap_bytes(), m);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn swap_bytes(self) -> Self;
-
-    /// Converts an integer from big endian to the target's endianness.
-    ///
-    /// On big endian this is a no-op. On little endian the bytes are swapped.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::num::Int;
-    ///
-    /// let n = 0x0123456789ABCDEFu64;
-    ///
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(Int::from_be(n), n)
-    /// } else {
-    ///     assert_eq!(Int::from_be(n), n.swap_bytes())
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    fn from_be(x: Self) -> Self {
-        if cfg!(target_endian = "big") { x } else { x.swap_bytes() }
-    }
-
-    /// Converts an integer from little endian to the target's endianness.
-    ///
-    /// On little endian this is a no-op. On big endian the bytes are swapped.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::num::Int;
-    ///
-    /// let n = 0x0123456789ABCDEFu64;
-    ///
-    /// if cfg!(target_endian = "little") {
-    ///     assert_eq!(Int::from_le(n), n)
-    /// } else {
-    ///     assert_eq!(Int::from_le(n), n.swap_bytes())
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    fn from_le(x: Self) -> Self {
-        if cfg!(target_endian = "little") { x } else { x.swap_bytes() }
-    }
-
-    /// Converts `self` to big endian from the target's endianness.
-    ///
-    /// On big endian this is a no-op. On little endian the bytes are swapped.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::num::Int;
-    ///
-    /// let n = 0x0123456789ABCDEFu64;
-    ///
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(n.to_be(), n)
-    /// } else {
-    ///     assert_eq!(n.to_be(), n.swap_bytes())
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    fn to_be(self) -> Self { // or not to be?
-        if cfg!(target_endian = "big") { self } else { self.swap_bytes() }
-    }
-
-    /// Converts `self` to little endian from the target's endianness.
-    ///
-    /// On little endian this is a no-op. On big endian the bytes are swapped.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::num::Int;
-    ///
-    /// let n = 0x0123456789ABCDEFu64;
-    ///
-    /// if cfg!(target_endian = "little") {
-    ///     assert_eq!(n.to_le(), n)
-    /// } else {
-    ///     assert_eq!(n.to_le(), n.swap_bytes())
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    fn to_le(self) -> Self {
-        if cfg!(target_endian = "little") { self } else { self.swap_bytes() }
-    }
-
-    /// Checked integer addition. Computes `self + other`, returning `None` if
-    /// overflow occurred.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::num::Int;
-    ///
-    /// assert_eq!(5u16.checked_add(65530), Some(65535));
-    /// assert_eq!(6u16.checked_add(65530), None);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn checked_add(self, other: Self) -> Option<Self>;
-
-    /// Checked integer subtraction. Computes `self - other`, returning `None`
-    /// if underflow occurred.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::num::Int;
-    ///
-    /// assert_eq!((-127i8).checked_sub(1), Some(-128));
-    /// assert_eq!((-128i8).checked_sub(1), None);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn checked_sub(self, other: Self) -> Option<Self>;
-
-    /// Checked integer multiplication. Computes `self * other`, returning
-    /// `None` if underflow or overflow occurred.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::num::Int;
-    ///
-    /// assert_eq!(5u8.checked_mul(51), Some(255));
-    /// assert_eq!(5u8.checked_mul(52), None);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn checked_mul(self, other: Self) -> Option<Self>;
-
-    /// Checked integer division. Computes `self / other`, returning `None` if
-    /// `other == 0` or the operation results in underflow or overflow.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::num::Int;
-    ///
-    /// assert_eq!((-127i8).checked_div(-1), Some(127));
-    /// assert_eq!((-128i8).checked_div(-1), None);
-    /// assert_eq!((1i8).checked_div(0), None);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn checked_div(self, other: Self) -> Option<Self>;
-
-    /// Saturating integer addition. Computes `self + other`, saturating at
-    /// the numeric bounds instead of overflowing.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::num::Int;
-    ///
-    /// assert_eq!(5u16.saturating_add(65534), 65535);
-    /// assert_eq!((-5i16).saturating_add(-32767), -32768);
-    /// assert_eq!(100u32.saturating_add(4294967294), 4294967295);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    fn saturating_add(self, other: Self) -> Self {
-        match self.checked_add(other) {
-            Some(x)                      => x,
-            None if other >= Int::zero() => Int::max_value(),
-            None                         => Int::min_value(),
-        }
-    }
-
-    /// Saturating integer subtraction. Computes `self - other`, saturating at
-    /// the numeric bounds instead of overflowing.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::num::Int;
-    ///
-    /// assert_eq!(5u16.saturating_sub(65534), 0);
-    /// assert_eq!(5i16.saturating_sub(-32767), 32767);
-    /// assert_eq!(100u32.saturating_sub(4294967294), 0);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    fn saturating_sub(self, other: Self) -> Self {
-        match self.checked_sub(other) {
-            Some(x)                      => x,
-            None if other >= Int::zero() => Int::min_value(),
-            None                         => Int::max_value(),
-        }
-    }
-
-    /// Raises self to the power of `exp`, using exponentiation by squaring.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(core)]
-    /// use std::num::Int;
-    ///
-    /// assert_eq!(2.pow(4), 16);
-    /// ```
-    #[unstable(feature = "core",
-               reason = "pending integer conventions")]
-    #[inline]
-    fn pow(self, mut exp: u32) -> Self {
-        let mut base = self;
-        let mut acc: Self = Int::one();
-
-        let mut prev_base = self;
-        let mut base_oflo = false;
-        while exp > 0 {
-            if (exp & 1) == 1 {
-                if base_oflo {
-                    // ensure overflow occurs in the same manner it
-                    // would have otherwise (i.e. signal any exception
-                    // it would have otherwise).
-                    acc = acc * (prev_base * prev_base);
-                } else {
-                    acc = acc * base;
-                }
-            }
-            prev_base = base;
-            let (new_base, new_base_oflo) = base.overflowing_mul(base);
-            base = new_base;
-            base_oflo = new_base_oflo;
-            exp /= 2;
-        }
-        acc
-    }
-}
-
 macro_rules! checked_op {
     ($T:ty, $U:ty, $op:path, $x:expr, $y:expr) => {{
         let (result, overflowed) = unsafe { $op($x as $U, $y as $U) };
@@ -506,328 +101,13 @@ macro_rules! checked_op {
     }}
 }
 
-macro_rules! uint_impl {
-    ($T:ty = $ActualT:ty, $BITS:expr,
-     $ctpop:path,
-     $ctlz:path,
-     $cttz:path,
-     $bswap:path,
-     $add_with_overflow:path,
-     $sub_with_overflow:path,
-     $mul_with_overflow:path) => {
-        #[stable(feature = "rust1", since = "1.0.0")]
-        #[allow(deprecated)]
-        impl Int for $T {
-            #[inline]
-            fn zero() -> $T { 0 }
-
-            #[inline]
-            fn one() -> $T { 1 }
-
-            #[inline]
-            fn min_value() -> $T { 0 }
-
-            #[inline]
-            fn max_value() -> $T { !0 }
-
-            #[inline]
-            fn count_ones(self) -> u32 {
-                unsafe { $ctpop(self as $ActualT) as u32 }
-            }
-
-            #[inline]
-            fn leading_zeros(self) -> u32 {
-                unsafe { $ctlz(self as $ActualT) as u32 }
-            }
-
-            #[inline]
-            fn trailing_zeros(self) -> u32 {
-                unsafe { $cttz(self as $ActualT) as u32 }
-            }
-
-            #[inline]
-            fn rotate_left(self, n: u32) -> $T {
-                // Protect against undefined behaviour for over-long bit shifts
-                let n = n % $BITS;
-                (self << n) | (self >> (($BITS - n) % $BITS))
-            }
-
-            #[inline]
-            fn rotate_right(self, n: u32) -> $T {
-                // Protect against undefined behaviour for over-long bit shifts
-                let n = n % $BITS;
-                (self >> n) | (self << (($BITS - n) % $BITS))
-            }
-
-            #[inline]
-            fn swap_bytes(self) -> $T {
-                unsafe { $bswap(self as $ActualT) as $T }
-            }
-
-            #[inline]
-            fn checked_add(self, other: $T) -> Option<$T> {
-                checked_op!($T, $ActualT, $add_with_overflow, self, other)
-            }
-
-            #[inline]
-            fn checked_sub(self, other: $T) -> Option<$T> {
-                checked_op!($T, $ActualT, $sub_with_overflow, self, other)
-            }
-
-            #[inline]
-            fn checked_mul(self, other: $T) -> Option<$T> {
-                checked_op!($T, $ActualT, $mul_with_overflow, self, other)
-            }
-
-            #[inline]
-            fn checked_div(self, v: $T) -> Option<$T> {
-                match v {
-                    0 => None,
-                    v => Some(self / v),
-                }
-            }
-        }
-    }
-}
-
 /// Swapping a single byte is a no-op. This is marked as `unsafe` for
 /// consistency with the other `bswap` intrinsics.
 unsafe fn bswap8(x: u8) -> u8 { x }
 
-uint_impl! { u8 = u8, 8,
-    intrinsics::ctpop8,
-    intrinsics::ctlz8,
-    intrinsics::cttz8,
-    bswap8,
-    intrinsics::u8_add_with_overflow,
-    intrinsics::u8_sub_with_overflow,
-    intrinsics::u8_mul_with_overflow }
-
-uint_impl! { u16 = u16, 16,
-    intrinsics::ctpop16,
-    intrinsics::ctlz16,
-    intrinsics::cttz16,
-    intrinsics::bswap16,
-    intrinsics::u16_add_with_overflow,
-    intrinsics::u16_sub_with_overflow,
-    intrinsics::u16_mul_with_overflow }
-
-uint_impl! { u32 = u32, 32,
-    intrinsics::ctpop32,
-    intrinsics::ctlz32,
-    intrinsics::cttz32,
-    intrinsics::bswap32,
-    intrinsics::u32_add_with_overflow,
-    intrinsics::u32_sub_with_overflow,
-    intrinsics::u32_mul_with_overflow }
-
-uint_impl! { u64 = u64, 64,
-    intrinsics::ctpop64,
-    intrinsics::ctlz64,
-    intrinsics::cttz64,
-    intrinsics::bswap64,
-    intrinsics::u64_add_with_overflow,
-    intrinsics::u64_sub_with_overflow,
-    intrinsics::u64_mul_with_overflow }
-
-#[cfg(target_pointer_width = "32")]
-uint_impl! { usize = u32, 32,
-    intrinsics::ctpop32,
-    intrinsics::ctlz32,
-    intrinsics::cttz32,
-    intrinsics::bswap32,
-    intrinsics::u32_add_with_overflow,
-    intrinsics::u32_sub_with_overflow,
-    intrinsics::u32_mul_with_overflow }
-
-#[cfg(target_pointer_width = "64")]
-uint_impl! { usize = u64, 64,
-    intrinsics::ctpop64,
-    intrinsics::ctlz64,
-    intrinsics::cttz64,
-    intrinsics::bswap64,
-    intrinsics::u64_add_with_overflow,
-    intrinsics::u64_sub_with_overflow,
-    intrinsics::u64_mul_with_overflow }
-
-macro_rules! int_impl {
-    ($T:ty = $ActualT:ty, $UnsignedT:ty, $BITS:expr,
-     $add_with_overflow:path,
-     $sub_with_overflow:path,
-     $mul_with_overflow:path) => {
-        #[stable(feature = "rust1", since = "1.0.0")]
-        #[allow(deprecated)]
-        impl Int for $T {
-            #[inline]
-            fn zero() -> $T { 0 }
-
-            #[inline]
-            fn one() -> $T { 1 }
-
-            #[inline]
-            fn min_value() -> $T { (-1 as $T) << ($BITS - 1) }
-
-            #[inline]
-            fn max_value() -> $T { let min: $T = Int::min_value(); !min }
-
-            #[inline]
-            fn count_ones(self) -> u32 { (self as $UnsignedT).count_ones() }
-
-            #[inline]
-            fn leading_zeros(self) -> u32 {
-                (self as $UnsignedT).leading_zeros()
-            }
-
-            #[inline]
-            fn trailing_zeros(self) -> u32 {
-                (self as $UnsignedT).trailing_zeros()
-            }
-
-            #[inline]
-            fn rotate_left(self, n: u32) -> $T {
-                (self as $UnsignedT).rotate_left(n) as $T
-            }
-
-            #[inline]
-            fn rotate_right(self, n: u32) -> $T {
-                (self as $UnsignedT).rotate_right(n) as $T
-            }
-
-            #[inline]
-            fn swap_bytes(self) -> $T {
-                (self as $UnsignedT).swap_bytes() as $T
-            }
-
-            #[inline]
-            fn checked_add(self, other: $T) -> Option<$T> {
-                checked_op!($T, $ActualT, $add_with_overflow, self, other)
-            }
-
-            #[inline]
-            fn checked_sub(self, other: $T) -> Option<$T> {
-                checked_op!($T, $ActualT, $sub_with_overflow, self, other)
-            }
-
-            #[inline]
-            fn checked_mul(self, other: $T) -> Option<$T> {
-                checked_op!($T, $ActualT, $mul_with_overflow, self, other)
-            }
-
-            #[inline]
-            fn checked_div(self, v: $T) -> Option<$T> {
-                match v {
-                    0   => None,
-                   -1 if self == Int::min_value()
-                        => None,
-                    v   => Some(self / v),
-                }
-            }
-        }
-    }
-}
-
-int_impl! { i8 = i8, u8, 8,
-    intrinsics::i8_add_with_overflow,
-    intrinsics::i8_sub_with_overflow,
-    intrinsics::i8_mul_with_overflow }
-
-int_impl! { i16 = i16, u16, 16,
-    intrinsics::i16_add_with_overflow,
-    intrinsics::i16_sub_with_overflow,
-    intrinsics::i16_mul_with_overflow }
-
-int_impl! { i32 = i32, u32, 32,
-    intrinsics::i32_add_with_overflow,
-    intrinsics::i32_sub_with_overflow,
-    intrinsics::i32_mul_with_overflow }
-
-int_impl! { i64 = i64, u64, 64,
-    intrinsics::i64_add_with_overflow,
-    intrinsics::i64_sub_with_overflow,
-    intrinsics::i64_mul_with_overflow }
-
-#[cfg(target_pointer_width = "32")]
-int_impl! { isize = i32, u32, 32,
-    intrinsics::i32_add_with_overflow,
-    intrinsics::i32_sub_with_overflow,
-    intrinsics::i32_mul_with_overflow }
-
-#[cfg(target_pointer_width = "64")]
-int_impl! { isize = i64, u64, 64,
-    intrinsics::i64_add_with_overflow,
-    intrinsics::i64_sub_with_overflow,
-    intrinsics::i64_mul_with_overflow }
-
-/// A built-in two's complement integer.
-#[stable(feature = "rust1", since = "1.0.0")]
-#[deprecated(since = "1.0.0",
-             reason = "replaced by inherent methods; for generics, use rust-lang/num")]
-#[allow(deprecated)]
-pub trait SignedInt
-    : Int
-    + Neg<Output=Self>
-{
-    /// Computes the absolute value of `self`. `Int::min_value()` will be
-    /// returned if the number is `Int::min_value()`.
-    #[unstable(feature = "core", reason = "overflow in debug builds?")]
-    fn abs(self) -> Self;
-
-    /// Returns a number representing sign of `self`.
-    ///
-    /// - `0` if the number is zero
-    /// - `1` if the number is positive
-    /// - `-1` if the number is negative
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn signum(self) -> Self;
-
-    /// Returns `true` if `self` is positive and `false` if the number
-    /// is zero or negative.
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn is_positive(self) -> bool;
-
-    /// Returns `true` if `self` is negative and `false` if the number
-    /// is zero or positive.
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn is_negative(self) -> bool;
-}
-
-macro_rules! signed_int_impl {
-    ($T:ty) => {
-        #[stable(feature = "rust1", since = "1.0.0")]
-        #[allow(deprecated)]
-        impl SignedInt for $T {
-            #[inline]
-            fn abs(self) -> $T {
-                if self.is_negative() { -self } else { self }
-            }
-
-            #[inline]
-            fn signum(self) -> $T {
-                match self {
-                    n if n > 0 =>  1,
-                    0          =>  0,
-                    _          => -1,
-                }
-            }
-
-            #[inline]
-            fn is_positive(self) -> bool { self > 0 }
-
-            #[inline]
-            fn is_negative(self) -> bool { self < 0 }
-        }
-    }
-}
-
-signed_int_impl! { i8 }
-signed_int_impl! { i16 }
-signed_int_impl! { i32 }
-signed_int_impl! { i64 }
-signed_int_impl! { isize }
-
 // `Int` + `SignedInt` implemented for signed integers
 macro_rules! int_impl {
-    ($T:ty = $ActualT:ty, $UnsignedT:ty, $BITS:expr,
+    ($T:ident = $ActualT:ty, $UnsignedT:ty, $BITS:expr,
      $add_with_overflow:path,
      $sub_with_overflow:path,
      $mul_with_overflow:path) => {
@@ -840,7 +120,7 @@ macro_rules! int_impl {
         /// Returns the largest value that can be represented by this integer type.
         #[stable(feature = "rust1", since = "1.0.0")]
         pub fn max_value() -> $T {
-            let min: $T = Int::min_value(); !min
+            let min = $T::min_value(); !min
         }
 
         /// Converts a string slice in a given base to an integer.
@@ -859,7 +139,7 @@ macro_rules! int_impl {
         #[stable(feature = "rust1", since = "1.0.0")]
         #[allow(deprecated)]
         pub fn from_str_radix(src: &str, radix: u32) -> Result<$T, ParseIntError> {
-            <Self as FromStrRadix>::from_str_radix(src, radix)
+            from_str_radix(src, radix)
         }
 
         /// Returns the number of ones in the binary representation of `self`.
@@ -867,9 +147,6 @@ macro_rules! int_impl {
         /// # Examples
         ///
         /// ```rust
-        /// # #![feature(core)]
-        /// use std::num::Int;
-        ///
         /// let n = 0b01001100u8;
         ///
         /// assert_eq!(n.count_ones(), 3);
@@ -883,9 +160,6 @@ macro_rules! int_impl {
         /// # Examples
         ///
         /// ```rust
-        /// # #![feature(core)]
-        /// use std::num::Int;
-        ///
         /// let n = 0b01001100u8;
         ///
         /// assert_eq!(n.count_zeros(), 5);
@@ -902,9 +176,6 @@ macro_rules! int_impl {
         /// # Examples
         ///
         /// ```rust
-        /// # #![feature(core)]
-        /// use std::num::Int;
-        ///
         /// let n = 0b0101000u16;
         ///
         /// assert_eq!(n.leading_zeros(), 10);
@@ -921,9 +192,6 @@ macro_rules! int_impl {
         /// # Examples
         ///
         /// ```rust
-        /// # #![feature(core)]
-        /// use std::num::Int;
-        ///
         /// let n = 0b0101000u16;
         ///
         /// assert_eq!(n.trailing_zeros(), 3);
@@ -940,9 +208,6 @@ macro_rules! int_impl {
         /// # Examples
         ///
         /// ```rust
-        /// # #![feature(core)]
-        /// use std::num::Int;
-        ///
         /// let n = 0x0123456789ABCDEFu64;
         /// let m = 0x3456789ABCDEF012u64;
         ///
@@ -961,9 +226,6 @@ macro_rules! int_impl {
         /// # Examples
         ///
         /// ```rust
-        /// # #![feature(core)]
-        /// use std::num::Int;
-        ///
         /// let n = 0x0123456789ABCDEFu64;
         /// let m = 0xDEF0123456789ABCu64;
         ///
@@ -980,8 +242,6 @@ macro_rules! int_impl {
         /// # Examples
         ///
         /// ```rust
-        /// use std::num::Int;
-        ///
         /// let n = 0x0123456789ABCDEFu64;
         /// let m = 0xEFCDAB8967452301u64;
         ///
@@ -1001,14 +261,12 @@ macro_rules! int_impl {
         /// # Examples
         ///
         /// ```rust
-        /// use std::num::Int;
-        ///
         /// let n = 0x0123456789ABCDEFu64;
         ///
         /// if cfg!(target_endian = "big") {
-        ///     assert_eq!(Int::from_be(n), n)
+        ///     assert_eq!(u64::from_be(n), n)
         /// } else {
-        ///     assert_eq!(Int::from_be(n), n.swap_bytes())
+        ///     assert_eq!(u64::from_be(n), n.swap_bytes())
         /// }
         /// ```
         #[stable(feature = "rust1", since = "1.0.0")]
@@ -1025,14 +283,12 @@ macro_rules! int_impl {
         /// # Examples
         ///
         /// ```rust
-        /// use std::num::Int;
-        ///
         /// let n = 0x0123456789ABCDEFu64;
         ///
         /// if cfg!(target_endian = "little") {
-        ///     assert_eq!(Int::from_le(n), n)
+        ///     assert_eq!(u64::from_le(n), n)
         /// } else {
-        ///     assert_eq!(Int::from_le(n), n.swap_bytes())
+        ///     assert_eq!(u64::from_le(n), n.swap_bytes())
         /// }
         /// ```
         #[stable(feature = "rust1", since = "1.0.0")]
@@ -1049,8 +305,6 @@ macro_rules! int_impl {
         /// # Examples
         ///
         /// ```rust
-        /// use std::num::Int;
-        ///
         /// let n = 0x0123456789ABCDEFu64;
         ///
         /// if cfg!(target_endian = "big") {
@@ -1073,8 +327,6 @@ macro_rules! int_impl {
         /// # Examples
         ///
         /// ```rust
-        /// use std::num::Int;
-        ///
         /// let n = 0x0123456789ABCDEFu64;
         ///
         /// if cfg!(target_endian = "little") {
@@ -1095,8 +347,6 @@ macro_rules! int_impl {
         /// # Examples
         ///
         /// ```rust
-        /// use std::num::Int;
-        ///
         /// assert_eq!(5u16.checked_add(65530), Some(65535));
         /// assert_eq!(6u16.checked_add(65530), None);
         /// ```
@@ -1112,8 +362,6 @@ macro_rules! int_impl {
         /// # Examples
         ///
         /// ```rust
-        /// use std::num::Int;
-        ///
         /// assert_eq!((-127i8).checked_sub(1), Some(-128));
         /// assert_eq!((-128i8).checked_sub(1), None);
         /// ```
@@ -1129,8 +377,6 @@ macro_rules! int_impl {
         /// # Examples
         ///
         /// ```rust
-        /// use std::num::Int;
-        ///
         /// assert_eq!(5u8.checked_mul(51), Some(255));
         /// assert_eq!(5u8.checked_mul(52), None);
         /// ```
@@ -1146,8 +392,6 @@ macro_rules! int_impl {
         /// # Examples
         ///
         /// ```rust
-        /// use std::num::Int;
-        ///
         /// assert_eq!((-127i8).checked_div(-1), Some(127));
         /// assert_eq!((-128i8).checked_div(-1), None);
         /// assert_eq!((1i8).checked_div(0), None);
@@ -1439,7 +683,7 @@ macro_rules! uint_impl {
         #[stable(feature = "rust1", since = "1.0.0")]
         #[allow(deprecated)]
         pub fn from_str_radix(src: &str, radix: u32) -> Result<$T, ParseIntError> {
-            <Self as FromStrRadix>::from_str_radix(src, radix)
+            from_str_radix(src, radix)
         }
 
         /// Returns the number of ones in the binary representation of `self`.
@@ -1447,9 +691,6 @@ macro_rules! uint_impl {
         /// # Examples
         ///
         /// ```rust
-        /// # #![feature(core)]
-        /// use std::num::Int;
-        ///
         /// let n = 0b01001100u8;
         ///
         /// assert_eq!(n.count_ones(), 3);
@@ -1465,9 +706,6 @@ macro_rules! uint_impl {
         /// # Examples
         ///
         /// ```rust
-        /// # #![feature(core)]
-        /// use std::num::Int;
-        ///
         /// let n = 0b01001100u8;
         ///
         /// assert_eq!(n.count_zeros(), 5);
@@ -1484,9 +722,6 @@ macro_rules! uint_impl {
         /// # Examples
         ///
         /// ```rust
-        /// # #![feature(core)]
-        /// use std::num::Int;
-        ///
         /// let n = 0b0101000u16;
         ///
         /// assert_eq!(n.leading_zeros(), 10);
@@ -1503,9 +738,6 @@ macro_rules! uint_impl {
         /// # Examples
         ///
         /// ```rust
-        /// # #![feature(core)]
-        /// use std::num::Int;
-        ///
         /// let n = 0b0101000u16;
         ///
         /// assert_eq!(n.trailing_zeros(), 3);
@@ -1522,9 +754,6 @@ macro_rules! uint_impl {
         /// # Examples
         ///
         /// ```rust
-        /// # #![feature(core)]
-        /// use std::num::Int;
-        ///
         /// let n = 0x0123456789ABCDEFu64;
         /// let m = 0x3456789ABCDEF012u64;
         ///
@@ -1545,9 +774,6 @@ macro_rules! uint_impl {
         /// # Examples
         ///
         /// ```rust
-        /// # #![feature(core)]
-        /// use std::num::Int;
-        ///
         /// let n = 0x0123456789ABCDEFu64;
         /// let m = 0xDEF0123456789ABCu64;
         ///
@@ -1566,8 +792,6 @@ macro_rules! uint_impl {
         /// # Examples
         ///
         /// ```rust
-        /// use std::num::Int;
-        ///
         /// let n = 0x0123456789ABCDEFu64;
         /// let m = 0xEFCDAB8967452301u64;
         ///
@@ -1587,14 +811,12 @@ macro_rules! uint_impl {
         /// # Examples
         ///
         /// ```rust
-        /// use std::num::Int;
-        ///
         /// let n = 0x0123456789ABCDEFu64;
         ///
         /// if cfg!(target_endian = "big") {
-        ///     assert_eq!(Int::from_be(n), n)
+        ///     assert_eq!(u64::from_be(n), n)
         /// } else {
-        ///     assert_eq!(Int::from_be(n), n.swap_bytes())
+        ///     assert_eq!(u64::from_be(n), n.swap_bytes())
         /// }
         /// ```
         #[stable(feature = "rust1", since = "1.0.0")]
@@ -1611,14 +833,12 @@ macro_rules! uint_impl {
         /// # Examples
         ///
         /// ```rust
-        /// use std::num::Int;
-        ///
         /// let n = 0x0123456789ABCDEFu64;
         ///
         /// if cfg!(target_endian = "little") {
-        ///     assert_eq!(Int::from_le(n), n)
+        ///     assert_eq!(u64::from_le(n), n)
         /// } else {
-        ///     assert_eq!(Int::from_le(n), n.swap_bytes())
+        ///     assert_eq!(u64::from_le(n), n.swap_bytes())
         /// }
         /// ```
         #[stable(feature = "rust1", since = "1.0.0")]
@@ -1635,8 +855,6 @@ macro_rules! uint_impl {
         /// # Examples
         ///
         /// ```rust
-        /// use std::num::Int;
-        ///
         /// let n = 0x0123456789ABCDEFu64;
         ///
         /// if cfg!(target_endian = "big") {
@@ -1659,8 +877,6 @@ macro_rules! uint_impl {
         /// # Examples
         ///
         /// ```rust
-        /// use std::num::Int;
-        ///
         /// let n = 0x0123456789ABCDEFu64;
         ///
         /// if cfg!(target_endian = "little") {
@@ -1681,8 +897,6 @@ macro_rules! uint_impl {
         /// # Examples
         ///
         /// ```rust
-        /// use std::num::Int;
-        ///
         /// assert_eq!(5u16.checked_add(65530), Some(65535));
         /// assert_eq!(6u16.checked_add(65530), None);
         /// ```
@@ -1698,8 +912,6 @@ macro_rules! uint_impl {
         /// # Examples
         ///
         /// ```rust
-        /// use std::num::Int;
-        ///
         /// assert_eq!((-127i8).checked_sub(1), Some(-128));
         /// assert_eq!((-128i8).checked_sub(1), None);
         /// ```
@@ -1715,8 +927,6 @@ macro_rules! uint_impl {
         /// # Examples
         ///
         /// ```rust
-        /// use std::num::Int;
-        ///
         /// assert_eq!(5u8.checked_mul(51), Some(255));
         /// assert_eq!(5u8.checked_mul(52), None);
         /// ```
@@ -1732,8 +942,6 @@ macro_rules! uint_impl {
         /// # Examples
         ///
         /// ```rust
-        /// use std::num::Int;
-        ///
         /// assert_eq!((-127i8).checked_div(-1), Some(127));
         /// assert_eq!((-128i8).checked_div(-1), None);
         /// assert_eq!((1i8).checked_div(0), None);
@@ -1866,10 +1074,7 @@ macro_rules! uint_impl {
         /// # Examples
         ///
         /// ```rust
-        /// # #![feature(core)]
-        /// use std::num::Int;
-        ///
-        /// assert_eq!(2.pow(4), 16);
+        /// assert_eq!(2i32.pow(4), 16);
         /// ```
         #[stable(feature = "rust1", since = "1.0.0")]
         #[inline]
@@ -2007,575 +1212,6 @@ impl usize {
         intrinsics::u64_mul_with_overflow }
 }
 
-/// A generic trait for converting a value to a number.
-#[unstable(feature = "core", reason = "trait is likely to be removed")]
-pub trait ToPrimitive {
-    /// Converts the value of `self` to an `isize`.
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0", reason = "use to_isize")]
-    fn to_int(&self) -> Option<isize> {
-        self.to_i64().and_then(|x| x.to_isize())
-    }
-
-    /// Converts the value of `self` to an `isize`.
-    #[inline]
-    fn to_isize(&self) -> Option<isize> {
-        self.to_i64().and_then(|x| x.to_isize())
-    }
-
-    /// Converts the value of `self` to an `i8`.
-    #[inline]
-    fn to_i8(&self) -> Option<i8> {
-        self.to_i64().and_then(|x| x.to_i8())
-    }
-
-    /// Converts the value of `self` to an `i16`.
-    #[inline]
-    fn to_i16(&self) -> Option<i16> {
-        self.to_i64().and_then(|x| x.to_i16())
-    }
-
-    /// Converts the value of `self` to an `i32`.
-    #[inline]
-    fn to_i32(&self) -> Option<i32> {
-        self.to_i64().and_then(|x| x.to_i32())
-    }
-
-    /// Converts the value of `self` to an `i64`.
-    fn to_i64(&self) -> Option<i64>;
-
-    /// Converts the value of `self` to an `usize`.
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0", reason = "use to_usize")]
-    fn to_uint(&self) -> Option<usize> {
-        self.to_u64().and_then(|x| x.to_usize())
-    }
-
-    /// Converts the value of `self` to a `usize`.
-    #[inline]
-    fn to_usize(&self) -> Option<usize> {
-        self.to_u64().and_then(|x| x.to_usize())
-    }
-
-    /// Converts the value of `self` to an `u8`.
-    #[inline]
-    fn to_u8(&self) -> Option<u8> {
-        self.to_u64().and_then(|x| x.to_u8())
-    }
-
-    /// Converts the value of `self` to an `u16`.
-    #[inline]
-    fn to_u16(&self) -> Option<u16> {
-        self.to_u64().and_then(|x| x.to_u16())
-    }
-
-    /// Converts the value of `self` to an `u32`.
-    #[inline]
-    fn to_u32(&self) -> Option<u32> {
-        self.to_u64().and_then(|x| x.to_u32())
-    }
-
-    /// Converts the value of `self` to an `u64`.
-    #[inline]
-    fn to_u64(&self) -> Option<u64>;
-
-    /// Converts the value of `self` to an `f32`.
-    #[inline]
-    fn to_f32(&self) -> Option<f32> {
-        self.to_f64().and_then(|x| x.to_f32())
-    }
-
-    /// Converts the value of `self` to an `f64`.
-    #[inline]
-    fn to_f64(&self) -> Option<f64> {
-        self.to_i64().and_then(|x| x.to_f64())
-    }
-}
-
-macro_rules! impl_to_primitive_int_to_int {
-    ($SrcT:ty, $DstT:ty, $slf:expr) => (
-        {
-            if size_of::<$SrcT>() <= size_of::<$DstT>() {
-                Some($slf as $DstT)
-            } else {
-                let n = $slf as i64;
-                let min_value: $DstT = Int::min_value();
-                let max_value: $DstT = Int::max_value();
-                if min_value as i64 <= n && n <= max_value as i64 {
-                    Some($slf as $DstT)
-                } else {
-                    None
-                }
-            }
-        }
-    )
-}
-
-macro_rules! impl_to_primitive_int_to_uint {
-    ($SrcT:ty, $DstT:ty, $slf:expr) => (
-        {
-            let zero: $SrcT = Int::zero();
-            let max_value: $DstT = Int::max_value();
-            if zero <= $slf && $slf as u64 <= max_value as u64 {
-                Some($slf as $DstT)
-            } else {
-                None
-            }
-        }
-    )
-}
-
-macro_rules! impl_to_primitive_int {
-    ($T:ty) => (
-        impl ToPrimitive for $T {
-            #[inline]
-            fn to_int(&self) -> Option<isize> { impl_to_primitive_int_to_int!($T, isize, *self) }
-            #[inline]
-            fn to_isize(&self) -> Option<isize> { impl_to_primitive_int_to_int!($T, isize, *self) }
-            #[inline]
-            fn to_i8(&self) -> Option<i8> { impl_to_primitive_int_to_int!($T, i8, *self) }
-            #[inline]
-            fn to_i16(&self) -> Option<i16> { impl_to_primitive_int_to_int!($T, i16, *self) }
-            #[inline]
-            fn to_i32(&self) -> Option<i32> { impl_to_primitive_int_to_int!($T, i32, *self) }
-            #[inline]
-            fn to_i64(&self) -> Option<i64> { impl_to_primitive_int_to_int!($T, i64, *self) }
-
-            #[inline]
-            fn to_uint(&self) -> Option<usize> { impl_to_primitive_int_to_uint!($T, usize, *self) }
-            #[inline]
-            fn to_usize(&self) -> Option<usize> { impl_to_primitive_int_to_uint!($T, usize, *self) }
-            #[inline]
-            fn to_u8(&self) -> Option<u8> { impl_to_primitive_int_to_uint!($T, u8, *self) }
-            #[inline]
-            fn to_u16(&self) -> Option<u16> { impl_to_primitive_int_to_uint!($T, u16, *self) }
-            #[inline]
-            fn to_u32(&self) -> Option<u32> { impl_to_primitive_int_to_uint!($T, u32, *self) }
-            #[inline]
-            fn to_u64(&self) -> Option<u64> { impl_to_primitive_int_to_uint!($T, u64, *self) }
-
-            #[inline]
-            fn to_f32(&self) -> Option<f32> { Some(*self as f32) }
-            #[inline]
-            fn to_f64(&self) -> Option<f64> { Some(*self as f64) }
-        }
-    )
-}
-
-impl_to_primitive_int! { isize }
-impl_to_primitive_int! { i8 }
-impl_to_primitive_int! { i16 }
-impl_to_primitive_int! { i32 }
-impl_to_primitive_int! { i64 }
-
-macro_rules! impl_to_primitive_uint_to_int {
-    ($DstT:ty, $slf:expr) => (
-        {
-            let max_value: $DstT = Int::max_value();
-            if $slf as u64 <= max_value as u64 {
-                Some($slf as $DstT)
-            } else {
-                None
-            }
-        }
-    )
-}
-
-macro_rules! impl_to_primitive_uint_to_uint {
-    ($SrcT:ty, $DstT:ty, $slf:expr) => (
-        {
-            if size_of::<$SrcT>() <= size_of::<$DstT>() {
-                Some($slf as $DstT)
-            } else {
-                let zero: $SrcT = Int::zero();
-                let max_value: $DstT = Int::max_value();
-                if zero <= $slf && $slf as u64 <= max_value as u64 {
-                    Some($slf as $DstT)
-                } else {
-                    None
-                }
-            }
-        }
-    )
-}
-
-macro_rules! impl_to_primitive_uint {
-    ($T:ty) => (
-        impl ToPrimitive for $T {
-            #[inline]
-            fn to_int(&self) -> Option<isize> { impl_to_primitive_uint_to_int!(isize, *self) }
-            #[inline]
-            fn to_isize(&self) -> Option<isize> { impl_to_primitive_uint_to_int!(isize, *self) }
-            #[inline]
-            fn to_i8(&self) -> Option<i8> { impl_to_primitive_uint_to_int!(i8, *self) }
-            #[inline]
-            fn to_i16(&self) -> Option<i16> { impl_to_primitive_uint_to_int!(i16, *self) }
-            #[inline]
-            fn to_i32(&self) -> Option<i32> { impl_to_primitive_uint_to_int!(i32, *self) }
-            #[inline]
-            fn to_i64(&self) -> Option<i64> { impl_to_primitive_uint_to_int!(i64, *self) }
-
-            #[inline]
-            fn to_uint(&self) -> Option<usize> { impl_to_primitive_uint_to_uint!($T, usize, *self) }
-            #[inline]
-            fn to_usize(&self) -> Option<usize> {
-                impl_to_primitive_uint_to_uint!($T, usize, *self)
-            }
-            #[inline]
-            fn to_u8(&self) -> Option<u8> { impl_to_primitive_uint_to_uint!($T, u8, *self) }
-            #[inline]
-            fn to_u16(&self) -> Option<u16> { impl_to_primitive_uint_to_uint!($T, u16, *self) }
-            #[inline]
-            fn to_u32(&self) -> Option<u32> { impl_to_primitive_uint_to_uint!($T, u32, *self) }
-            #[inline]
-            fn to_u64(&self) -> Option<u64> { impl_to_primitive_uint_to_uint!($T, u64, *self) }
-
-            #[inline]
-            fn to_f32(&self) -> Option<f32> { Some(*self as f32) }
-            #[inline]
-            fn to_f64(&self) -> Option<f64> { Some(*self as f64) }
-        }
-    )
-}
-
-impl_to_primitive_uint! { usize }
-impl_to_primitive_uint! { u8 }
-impl_to_primitive_uint! { u16 }
-impl_to_primitive_uint! { u32 }
-impl_to_primitive_uint! { u64 }
-
-macro_rules! impl_to_primitive_float_to_float {
-    ($SrcT:ident, $DstT:ident, $slf:expr) => (
-        if size_of::<$SrcT>() <= size_of::<$DstT>() {
-            Some($slf as $DstT)
-        } else {
-            let n = $slf as f64;
-            let max_value: $SrcT = ::$SrcT::MAX;
-            if -max_value as f64 <= n && n <= max_value as f64 {
-                Some($slf as $DstT)
-            } else {
-                None
-            }
-        }
-    )
-}
-
-macro_rules! impl_to_primitive_float {
-    ($T:ident) => (
-        impl ToPrimitive for $T {
-            #[inline]
-            fn to_int(&self) -> Option<isize> { Some(*self as isize) }
-            #[inline]
-            fn to_isize(&self) -> Option<isize> { Some(*self as isize) }
-            #[inline]
-            fn to_i8(&self) -> Option<i8> { Some(*self as i8) }
-            #[inline]
-            fn to_i16(&self) -> Option<i16> { Some(*self as i16) }
-            #[inline]
-            fn to_i32(&self) -> Option<i32> { Some(*self as i32) }
-            #[inline]
-            fn to_i64(&self) -> Option<i64> { Some(*self as i64) }
-
-            #[inline]
-            fn to_uint(&self) -> Option<usize> { Some(*self as usize) }
-            #[inline]
-            fn to_usize(&self) -> Option<usize> { Some(*self as usize) }
-            #[inline]
-            fn to_u8(&self) -> Option<u8> { Some(*self as u8) }
-            #[inline]
-            fn to_u16(&self) -> Option<u16> { Some(*self as u16) }
-            #[inline]
-            fn to_u32(&self) -> Option<u32> { Some(*self as u32) }
-            #[inline]
-            fn to_u64(&self) -> Option<u64> { Some(*self as u64) }
-
-            #[inline]
-            fn to_f32(&self) -> Option<f32> { impl_to_primitive_float_to_float!($T, f32, *self) }
-            #[inline]
-            fn to_f64(&self) -> Option<f64> { impl_to_primitive_float_to_float!($T, f64, *self) }
-        }
-    )
-}
-
-impl_to_primitive_float! { f32 }
-impl_to_primitive_float! { f64 }
-
-/// A generic trait for converting a number to a value.
-#[unstable(feature = "core", reason = "trait is likely to be removed")]
-pub trait FromPrimitive : ::marker::Sized {
-    /// Converts an `isize` to return an optional value of this type. If the
-    /// value cannot be represented by this value, the `None` is returned.
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0", reason = "use from_isize")]
-    fn from_int(n: isize) -> Option<Self> {
-        FromPrimitive::from_i64(n as i64)
-    }
-
-    /// Converts an `isize` to return an optional value of this type. If the
-    /// value cannot be represented by this value, the `None` is returned.
-    #[inline]
-    fn from_isize(n: isize) -> Option<Self> {
-        FromPrimitive::from_i64(n as i64)
-    }
-
-    /// Converts an `i8` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    #[inline]
-    fn from_i8(n: i8) -> Option<Self> {
-        FromPrimitive::from_i64(n as i64)
-    }
-
-    /// Converts an `i16` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    #[inline]
-    fn from_i16(n: i16) -> Option<Self> {
-        FromPrimitive::from_i64(n as i64)
-    }
-
-    /// Converts an `i32` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    #[inline]
-    fn from_i32(n: i32) -> Option<Self> {
-        FromPrimitive::from_i64(n as i64)
-    }
-
-    /// Converts an `i64` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    fn from_i64(n: i64) -> Option<Self>;
-
-    /// Converts an `usize` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    #[inline]
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0", reason = "use from_usize")]
-    fn from_uint(n: usize) -> Option<Self> {
-        FromPrimitive::from_u64(n as u64)
-    }
-
-    /// Converts a `usize` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    #[inline]
-    fn from_usize(n: usize) -> Option<Self> {
-        FromPrimitive::from_u64(n as u64)
-    }
-
-    /// Converts an `u8` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    #[inline]
-    fn from_u8(n: u8) -> Option<Self> {
-        FromPrimitive::from_u64(n as u64)
-    }
-
-    /// Converts an `u16` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    #[inline]
-    fn from_u16(n: u16) -> Option<Self> {
-        FromPrimitive::from_u64(n as u64)
-    }
-
-    /// Converts an `u32` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    #[inline]
-    fn from_u32(n: u32) -> Option<Self> {
-        FromPrimitive::from_u64(n as u64)
-    }
-
-    /// Converts an `u64` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    fn from_u64(n: u64) -> Option<Self>;
-
-    /// Converts a `f32` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    #[inline]
-    fn from_f32(n: f32) -> Option<Self> {
-        FromPrimitive::from_f64(n as f64)
-    }
-
-    /// Converts a `f64` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    #[inline]
-    fn from_f64(n: f64) -> Option<Self> {
-        FromPrimitive::from_i64(n as i64)
-    }
-}
-
-/// A utility function that just calls `FromPrimitive::from_int`.
-#[unstable(feature = "core", reason = "likely to be removed")]
-#[deprecated(since = "1.0.0", reason = "use from_isize")]
-pub fn from_int<A: FromPrimitive>(n: isize) -> Option<A> {
-    FromPrimitive::from_isize(n)
-}
-
-/// A utility function that just calls `FromPrimitive::from_isize`.
-#[unstable(feature = "core", reason = "likely to be removed")]
-pub fn from_isize<A: FromPrimitive>(n: isize) -> Option<A> {
-    FromPrimitive::from_isize(n)
-}
-
-/// A utility function that just calls `FromPrimitive::from_i8`.
-#[unstable(feature = "core", reason = "likely to be removed")]
-pub fn from_i8<A: FromPrimitive>(n: i8) -> Option<A> {
-    FromPrimitive::from_i8(n)
-}
-
-/// A utility function that just calls `FromPrimitive::from_i16`.
-#[unstable(feature = "core", reason = "likely to be removed")]
-pub fn from_i16<A: FromPrimitive>(n: i16) -> Option<A> {
-    FromPrimitive::from_i16(n)
-}
-
-/// A utility function that just calls `FromPrimitive::from_i32`.
-#[unstable(feature = "core", reason = "likely to be removed")]
-pub fn from_i32<A: FromPrimitive>(n: i32) -> Option<A> {
-    FromPrimitive::from_i32(n)
-}
-
-/// A utility function that just calls `FromPrimitive::from_i64`.
-#[unstable(feature = "core", reason = "likely to be removed")]
-pub fn from_i64<A: FromPrimitive>(n: i64) -> Option<A> {
-    FromPrimitive::from_i64(n)
-}
-
-/// A utility function that just calls `FromPrimitive::from_uint`.
-#[unstable(feature = "core", reason = "likely to be removed")]
-#[deprecated(since = "1.0.0", reason = "use from_uint")]
-pub fn from_uint<A: FromPrimitive>(n: usize) -> Option<A> {
-    FromPrimitive::from_usize(n)
-}
-
-/// A utility function that just calls `FromPrimitive::from_usize`.
-#[unstable(feature = "core", reason = "likely to be removed")]
-pub fn from_usize<A: FromPrimitive>(n: usize) -> Option<A> {
-    FromPrimitive::from_usize(n)
-}
-
-/// A utility function that just calls `FromPrimitive::from_u8`.
-#[unstable(feature = "core", reason = "likely to be removed")]
-pub fn from_u8<A: FromPrimitive>(n: u8) -> Option<A> {
-    FromPrimitive::from_u8(n)
-}
-
-/// A utility function that just calls `FromPrimitive::from_u16`.
-#[unstable(feature = "core", reason = "likely to be removed")]
-pub fn from_u16<A: FromPrimitive>(n: u16) -> Option<A> {
-    FromPrimitive::from_u16(n)
-}
-
-/// A utility function that just calls `FromPrimitive::from_u32`.
-#[unstable(feature = "core", reason = "likely to be removed")]
-pub fn from_u32<A: FromPrimitive>(n: u32) -> Option<A> {
-    FromPrimitive::from_u32(n)
-}
-
-/// A utility function that just calls `FromPrimitive::from_u64`.
-#[unstable(feature = "core", reason = "likely to be removed")]
-pub fn from_u64<A: FromPrimitive>(n: u64) -> Option<A> {
-    FromPrimitive::from_u64(n)
-}
-
-/// A utility function that just calls `FromPrimitive::from_f32`.
-#[unstable(feature = "core", reason = "likely to be removed")]
-pub fn from_f32<A: FromPrimitive>(n: f32) -> Option<A> {
-    FromPrimitive::from_f32(n)
-}
-
-/// A utility function that just calls `FromPrimitive::from_f64`.
-#[unstable(feature = "core", reason = "likely to be removed")]
-pub fn from_f64<A: FromPrimitive>(n: f64) -> Option<A> {
-    FromPrimitive::from_f64(n)
-}
-
-macro_rules! impl_from_primitive {
-    ($T:ty, $to_ty:ident) => (
-        #[allow(deprecated)]
-        impl FromPrimitive for $T {
-            #[inline] fn from_int(n: isize) -> Option<$T> { n.$to_ty() }
-            #[inline] fn from_i8(n: i8) -> Option<$T> { n.$to_ty() }
-            #[inline] fn from_i16(n: i16) -> Option<$T> { n.$to_ty() }
-            #[inline] fn from_i32(n: i32) -> Option<$T> { n.$to_ty() }
-            #[inline] fn from_i64(n: i64) -> Option<$T> { n.$to_ty() }
-
-            #[inline] fn from_uint(n: usize) -> Option<$T> { n.$to_ty() }
-            #[inline] fn from_u8(n: u8) -> Option<$T> { n.$to_ty() }
-            #[inline] fn from_u16(n: u16) -> Option<$T> { n.$to_ty() }
-            #[inline] fn from_u32(n: u32) -> Option<$T> { n.$to_ty() }
-            #[inline] fn from_u64(n: u64) -> Option<$T> { n.$to_ty() }
-
-            #[inline] fn from_f32(n: f32) -> Option<$T> { n.$to_ty() }
-            #[inline] fn from_f64(n: f64) -> Option<$T> { n.$to_ty() }
-        }
-    )
-}
-
-impl_from_primitive! { isize, to_int }
-impl_from_primitive! { i8, to_i8 }
-impl_from_primitive! { i16, to_i16 }
-impl_from_primitive! { i32, to_i32 }
-impl_from_primitive! { i64, to_i64 }
-impl_from_primitive! { usize, to_uint }
-impl_from_primitive! { u8, to_u8 }
-impl_from_primitive! { u16, to_u16 }
-impl_from_primitive! { u32, to_u32 }
-impl_from_primitive! { u64, to_u64 }
-impl_from_primitive! { f32, to_f32 }
-impl_from_primitive! { f64, to_f64 }
-
-/// Casts from one machine scalar to another.
-///
-/// # Examples
-///
-/// ```
-/// # #![feature(core)]
-/// use std::num;
-///
-/// let twenty: f32 = num::cast(0x14).unwrap();
-/// assert_eq!(twenty, 20f32);
-/// ```
-///
-#[inline]
-#[unstable(feature = "core", reason = "likely to be removed")]
-pub fn cast<T: NumCast,U: NumCast>(n: T) -> Option<U> {
-    NumCast::from(n)
-}
-
-/// An interface for casting between machine scalars.
-#[unstable(feature = "core", reason = "trait is likely to be removed")]
-pub trait NumCast: ToPrimitive {
-    /// Creates a number from another value that can be converted into a primitive via the
-    /// `ToPrimitive` trait.
-    fn from<T: ToPrimitive>(n: T) -> Option<Self>;
-}
-
-macro_rules! impl_num_cast {
-    ($T:ty, $conv:ident) => (
-        impl NumCast for $T {
-            #[inline]
-            #[allow(deprecated)]
-            fn from<N: ToPrimitive>(n: N) -> Option<$T> {
-                // `$conv` could be generated using `concat_idents!`, but that
-                // macro seems to be broken at the moment
-                n.$conv()
-            }
-        }
-    )
-}
-
-impl_num_cast! { u8,    to_u8 }
-impl_num_cast! { u16,   to_u16 }
-impl_num_cast! { u32,   to_u32 }
-impl_num_cast! { u64,   to_u64 }
-impl_num_cast! { usize,  to_uint }
-impl_num_cast! { i8,    to_i8 }
-impl_num_cast! { i16,   to_i16 }
-impl_num_cast! { i32,   to_i32 }
-impl_num_cast! { i64,   to_i64 }
-impl_num_cast! { isize,   to_int }
-impl_num_cast! { f32,   to_f32 }
-impl_num_cast! { f64,   to_f64 }
-
 /// Used for representing the classification of floating point numbers
 #[derive(Copy, Clone, PartialEq, Debug)]
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -2602,93 +1238,22 @@ pub enum FpCategory {
 }
 
 /// A built-in floating point number.
-// FIXME(#5527): In a future version of Rust, many of these functions will
-//               become constants.
-//
-// FIXME(#8888): Several of these functions have a parameter named
-//               `unused_self`. Removing it requires #8888 to be fixed.
-#[unstable(feature = "core",
-           reason = "distribution of methods between core/std is unclear")]
 #[doc(hidden)]
-pub trait Float
-    : Copy + Clone
-    + NumCast
-    + PartialOrd
-    + PartialEq
-    + Neg<Output=Self>
-    + Add<Output=Self>
-    + Sub<Output=Self>
-    + Mul<Output=Self>
-    + Div<Output=Self>
-    + Rem<Output=Self>
-{
+pub trait Float {
     /// Returns the NaN value.
     fn nan() -> Self;
     /// Returns the infinite value.
     fn infinity() -> Self;
     /// Returns the negative infinite value.
     fn neg_infinity() -> Self;
-    /// Returns the `0` value.
-    fn zero() -> Self;
     /// Returns -0.0.
     fn neg_zero() -> Self;
-    /// Returns the `1` value.
+    /// Returns 0.0.
+    fn zero() -> Self;
+    /// Returns 1.0.
     fn one() -> Self;
-
-    // FIXME (#5527): These should be associated constants
-
-    /// Returns the number of binary digits of mantissa that this type supports.
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0",
-                 reason = "use `std::f32::MANTISSA_DIGITS` or \
-                           `std::f64::MANTISSA_DIGITS` as appropriate")]
-    fn mantissa_digits(unused_self: Option<Self>) -> usize;
-    /// Returns the number of base-10 digits of precision that this type supports.
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0",
-                 reason = "use `std::f32::DIGITS` or `std::f64::DIGITS` as appropriate")]
-    fn digits(unused_self: Option<Self>) -> usize;
-    /// Returns the difference between 1.0 and the smallest representable number larger than 1.0.
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0",
-                 reason = "use `std::f32::EPSILON` or `std::f64::EPSILON` as appropriate")]
-    fn epsilon() -> Self;
-    /// Returns the minimum binary exponent that this type can represent.
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0",
-                 reason = "use `std::f32::MIN_EXP` or `std::f64::MIN_EXP` as appropriate")]
-    fn min_exp(unused_self: Option<Self>) -> isize;
-    /// Returns the maximum binary exponent that this type can represent.
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0",
-                 reason = "use `std::f32::MAX_EXP` or `std::f64::MAX_EXP` as appropriate")]
-    fn max_exp(unused_self: Option<Self>) -> isize;
-    /// Returns the minimum base-10 exponent that this type can represent.
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0",
-                 reason = "use `std::f32::MIN_10_EXP` or `std::f64::MIN_10_EXP` as appropriate")]
-    fn min_10_exp(unused_self: Option<Self>) -> isize;
-    /// Returns the maximum base-10 exponent that this type can represent.
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0",
-                 reason = "use `std::f32::MAX_10_EXP` or `std::f64::MAX_10_EXP` as appropriate")]
-    fn max_10_exp(unused_self: Option<Self>) -> isize;
-    /// Returns the smallest finite value that this type can represent.
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0",
-                 reason = "use `std::f32::MIN` or `std::f64::MIN` as appropriate")]
-    fn min_value() -> Self;
-    /// Returns the smallest normalized positive number that this type can represent.
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0",
-                 reason = "use `std::f32::MIN_POSITIVE` or \
-                           `std::f64::MIN_POSITIVE` as appropriate")]
-    fn min_pos_value(unused_self: Option<Self>) -> Self;
-    /// Returns the largest finite value that this type can represent.
-    #[unstable(feature = "core")]
-    #[deprecated(since = "1.0.0",
-                 reason = "use `std::f32::MAX` or `std::f64::MAX` as appropriate")]
-    fn max_value() -> Self;
+    /// Parses the string `s` with the radix `r` as a float.
+    fn from_str_radix(s: &str, r: u32) -> Result<Self, ParseFloatError>;
 
     /// Returns true if this value is NaN and false otherwise.
     fn is_nan(self) -> bool;
@@ -2705,16 +1270,16 @@ pub trait Float
     /// Returns the mantissa, exponent and sign as integers, respectively.
     fn integer_decode(self) -> (u64, i16, i8);
 
-    /// Returns the largest integer less than or equal to a number.
+    /// Return the largest integer less than or equal to a number.
     fn floor(self) -> Self;
-    /// Returns the smallest integer greater than or equal to a number.
+    /// Return the smallest integer greater than or equal to a number.
     fn ceil(self) -> Self;
-    /// Returns the nearest integer to a number. Round half-way cases away from
+    /// Return the nearest integer to a number. Round half-way cases away from
     /// `0.0`.
     fn round(self) -> Self;
-    /// Returns the integer part of a number.
+    /// Return the integer part of a number.
     fn trunc(self) -> Self;
-    /// Returns the fractional part of a number.
+    /// Return the fractional part of a number.
     fn fract(self) -> Self;
 
     /// Computes the absolute value of `self`. Returns `Float::nan()` if the
@@ -2737,21 +1302,21 @@ pub trait Float
     /// error. This produces a more accurate result with better performance than
     /// a separate multiplication operation followed by an add.
     fn mul_add(self, a: Self, b: Self) -> Self;
-    /// Takes the reciprocal (inverse) of a number, `1/x`.
+    /// Take the reciprocal (inverse) of a number, `1/x`.
     fn recip(self) -> Self;
 
-    /// Raises a number to an integer power.
+    /// Raise a number to an integer power.
     ///
     /// Using this function is generally faster than using `powf`
     fn powi(self, n: i32) -> Self;
-    /// Raises a number to a floating point power.
+    /// Raise a number to a floating point power.
     fn powf(self, n: Self) -> Self;
 
-    /// Takes the square root of a number.
+    /// Take the square root of a number.
     ///
     /// Returns NaN if `self` is a negative number.
     fn sqrt(self) -> Self;
-    /// Takes the reciprocal (inverse) square root of a number, `1/sqrt(x)`.
+    /// Take the reciprocal (inverse) square root of a number, `1/sqrt(x)`.
     fn rsqrt(self) -> Self;
 
     /// Returns `e^(self)`, (the exponential function).
@@ -2767,39 +1332,14 @@ pub trait Float
     /// Returns the base 10 logarithm of the number.
     fn log10(self) -> Self;
 
-    /// Converts radians to degrees.
+    /// Convert radians to degrees.
     fn to_degrees(self) -> Self;
-    /// Converts degrees to radians.
+    /// Convert degrees to radians.
     fn to_radians(self) -> Self;
 }
 
-/// A generic trait for converting a string with a radix (base) to a value
-#[unstable(feature = "core", reason = "needs reevaluation")]
-#[deprecated(since = "1.0.0",
-             reason = "moved to inherent methods; use e.g. i32::from_str_radix")]
-pub trait FromStrRadix {
-    #[unstable(feature = "core", reason = "needs reevaluation")]
-    #[deprecated(since = "1.0.0", reason = "moved to inherent methods")]
-    type Err;
-
-    #[unstable(feature = "core", reason = "needs reevaluation")]
-    #[deprecated(since = "1.0.0",
-                 reason = "moved to inherent methods; use e.g. i32::from_str_radix")]
-    #[allow(deprecated)]
-    fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::Err>;
-}
-
-/// A utility function that just calls `FromStrRadix::from_str_radix`.
-#[unstable(feature = "core", reason = "needs reevaluation")]
-#[deprecated(since = "1.0.0", reason = "use e.g. i32::from_str_radix")]
-#[allow(deprecated)]
-pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: u32)
-                                       -> Result<T, T::Err> {
-    FromStrRadix::from_str_radix(str, radix)
-}
-
-macro_rules! from_str_radix_float_impl {
-    ($T:ty) => {
+macro_rules! from_str_float_impl {
+    ($T:ident) => {
         #[stable(feature = "rust1", since = "1.0.0")]
         impl FromStr for $T {
             type Err = ParseFloatError;
@@ -2827,265 +1367,113 @@ macro_rules! from_str_radix_float_impl {
             ///
             /// # Return value
             ///
-            /// `Err(ParseFloatError)` if the string did not represent a valid number.
-            /// Otherwise, `Ok(n)` where `n` is the floating-point number represented by `src`.
+            /// `Err(ParseFloatError)` if the string did not represent a valid
+            /// number.  Otherwise, `Ok(n)` where `n` is the floating-point
+            /// number represented by `src`.
             #[inline]
             #[allow(deprecated)]
             fn from_str(src: &str) -> Result<$T, ParseFloatError> {
-                from_str_radix(src, 10)
-            }
-        }
-
-        #[stable(feature = "rust1", since = "1.0.0")]
-        #[allow(deprecated)]
-        impl FromStrRadix for $T {
-            type Err = ParseFloatError;
-
-            /// Converts a string in a given base to a float.
-            ///
-            /// Due to possible conflicts, this function does **not** accept
-            /// the special values `inf`, `-inf`, `+inf` and `NaN`, **nor**
-            /// does it recognize exponents of any kind.
-            ///
-            /// Leading and trailing whitespace represent an error.
-            ///
-            /// # Arguments
-            ///
-            /// * src - A string
-            /// * radix - The base to use. Must lie in the range [2 .. 36]
-            ///
-            /// # Return value
-            ///
-            /// `Err(ParseFloatError)` if the string did not represent a valid number.
-            /// Otherwise, `Ok(n)` where `n` is the floating-point number represented by `src`.
-            fn from_str_radix(src: &str, radix: u32)
-                              -> Result<$T, ParseFloatError> {
-                use self::FloatErrorKind::*;
-                use self::ParseFloatError as PFE;
-                assert!(radix >= 2 && radix <= 36,
-                       "from_str_radix_float: must lie in the range `[2, 36]` - found {}",
-                       radix);
-
-                // Special values
-                match src {
-                    "inf"   => return Ok(Float::infinity()),
-                    "-inf"  => return Ok(Float::neg_infinity()),
-                    "NaN"   => return Ok(Float::nan()),
-                    _       => {},
-                }
-
-                let (is_positive, src) =  match src.slice_shift_char() {
-                    None             => return Err(PFE { kind: Empty }),
-                    Some(('-', ""))  => return Err(PFE { kind: Empty }),
-                    Some(('-', src)) => (false, src),
-                    Some((_, _))     => (true,  src),
-                };
-
-                // The significand to accumulate
-                let mut sig = if is_positive { 0.0 } else { -0.0 };
-                // Necessary to detect overflow
-                let mut prev_sig = sig;
-                let mut cs = src.chars().enumerate();
-                // Exponent prefix and exponent index offset
-                let mut exp_info = None::<(char, usize)>;
-
-                // Parse the integer part of the significand
-                for (i, c) in cs.by_ref() {
-                    match c.to_digit(radix) {
-                        Some(digit) => {
-                            // shift significand one digit left
-                            sig = sig * (radix as $T);
-
-                            // add/subtract current digit depending on sign
-                            if is_positive {
-                                sig = sig + ((digit as isize) as $T);
-                            } else {
-                                sig = sig - ((digit as isize) as $T);
-                            }
-
-                            // Detect overflow by comparing to last value, except
-                            // if we've not seen any non-zero digits.
-                            if prev_sig != 0.0 {
-                                if is_positive && sig <= prev_sig
-                                    { return Ok(Float::infinity()); }
-                                if !is_positive && sig >= prev_sig
-                                    { return Ok(Float::neg_infinity()); }
-
-                                // Detect overflow by reversing the shift-and-add process
-                                if is_positive && (prev_sig != (sig - digit as $T) / radix as $T)
-                                    { return Ok(Float::infinity()); }
-                                if !is_positive && (prev_sig != (sig + digit as $T) / radix as $T)
-                                    { return Ok(Float::neg_infinity()); }
-                            }
-                            prev_sig = sig;
-                        },
-                        None => match c {
-                            'e' | 'E' | 'p' | 'P' => {
-                                exp_info = Some((c, i + 1));
-                                break;  // start of exponent
-                            },
-                            '.' => {
-                                break;  // start of fractional part
-                            },
-                            _ => {
-                                return Err(PFE { kind: Invalid });
-                            },
-                        },
-                    }
-                }
-
-                // If we are not yet at the exponent parse the fractional
-                // part of the significand
-                if exp_info.is_none() {
-                    let mut power = 1.0;
-                    for (i, c) in cs.by_ref() {
-                        match c.to_digit(radix) {
-                            Some(digit) => {
-                                // Decrease power one order of magnitude
-                                power = power / (radix as $T);
-                                // add/subtract current digit depending on sign
-                                sig = if is_positive {
-                                    sig + (digit as $T) * power
-                                } else {
-                                    sig - (digit as $T) * power
-                                };
-                                // Detect overflow by comparing to last value
-                                if is_positive && sig < prev_sig
-                                    { return Ok(Float::infinity()); }
-                                if !is_positive && sig > prev_sig
-                                    { return Ok(Float::neg_infinity()); }
-                                prev_sig = sig;
-                            },
-                            None => match c {
-                                'e' | 'E' | 'p' | 'P' => {
-                                    exp_info = Some((c, i + 1));
-                                    break; // start of exponent
-                                },
-                                _ => {
-                                    return Err(PFE { kind: Invalid });
-                                },
-                            },
-                        }
-                    }
-                }
-
-                // Parse and calculate the exponent
-                let exp = match exp_info {
-                    Some((c, offset)) => {
-                        let base = match c {
-                            'E' | 'e' if radix == 10 => 10.0,
-                            'P' | 'p' if radix == 16 => 2.0,
-                            _ => return Err(PFE { kind: Invalid }),
-                        };
-
-                        // Parse the exponent as decimal integer
-                        let src = &src[offset..];
-                        let (is_positive, exp) = match src.slice_shift_char() {
-                            Some(('-', src)) => (false, src.parse::<usize>()),
-                            Some(('+', src)) => (true,  src.parse::<usize>()),
-                            Some((_, _))     => (true,  src.parse::<usize>()),
-                            None             => return Err(PFE { kind: Invalid }),
-                        };
-
-                        match (is_positive, exp) {
-                            (true,  Ok(exp)) => base.powi(exp as i32),
-                            (false, Ok(exp)) => 1.0 / base.powi(exp as i32),
-                            (_, Err(_))      => return Err(PFE { kind: Invalid }),
-                        }
-                    },
-                    None => 1.0, // no exponent
-                };
-
-                Ok(sig * exp)
+                $T::from_str_radix(src, 10)
             }
         }
     }
 }
-from_str_radix_float_impl! { f32 }
-from_str_radix_float_impl! { f64 }
+from_str_float_impl!(f32);
+from_str_float_impl!(f64);
 
 macro_rules! from_str_radix_int_impl {
-    ($T:ty) => {
+    ($($T:ident)*) => {$(
         #[stable(feature = "rust1", since = "1.0.0")]
         #[allow(deprecated)]
         impl FromStr for $T {
             type Err = ParseIntError;
-            #[inline]
             fn from_str(src: &str) -> Result<$T, ParseIntError> {
                 from_str_radix(src, 10)
             }
         }
+    )*}
+}
+from_str_radix_int_impl! { isize i8 i16 i32 i64 usize u8 u16 u32 u64 }
 
-        #[stable(feature = "rust1", since = "1.0.0")]
-        #[allow(deprecated)]
-        impl FromStrRadix for $T {
-            type Err = ParseIntError;
-            fn from_str_radix(src: &str, radix: u32)
-                              -> Result<$T, ParseIntError> {
-                use self::IntErrorKind::*;
-                use self::ParseIntError as PIE;
-                assert!(radix >= 2 && radix <= 36,
-                       "from_str_radix_int: must lie in the range `[2, 36]` - found {}",
-                       radix);
-
-                let is_signed_ty = (0 as $T) > Int::min_value();
-
-                match src.slice_shift_char() {
-                    Some(('-', "")) => Err(PIE { kind: Empty }),
-                    Some(('-', src)) if is_signed_ty => {
-                        // The number is negative
-                        let mut result = 0;
-                        for c in src.chars() {
-                            let x = match c.to_digit(radix) {
-                                Some(x) => x,
-                                None => return Err(PIE { kind: InvalidDigit }),
-                            };
-                            result = match result.checked_mul(radix as $T) {
-                                Some(result) => result,
-                                None => return Err(PIE { kind: Underflow }),
-                            };
-                            result = match result.checked_sub(x as $T) {
-                                Some(result) => result,
-                                None => return Err(PIE { kind: Underflow }),
-                            };
-                        }
-                        Ok(result)
-                    },
-                    Some((_, _)) => {
-                        // The number is signed
-                        let mut result = 0;
-                        for c in src.chars() {
-                            let x = match c.to_digit(radix) {
-                                Some(x) => x,
-                                None => return Err(PIE { kind: InvalidDigit }),
-                            };
-                            result = match result.checked_mul(radix as $T) {
-                                Some(result) => result,
-                                None => return Err(PIE { kind: Overflow }),
-                            };
-                            result = match result.checked_add(x as $T) {
-                                Some(result) => result,
-                                None => return Err(PIE { kind: Overflow }),
-                            };
-                        }
-                        Ok(result)
-                    },
-                    None => Err(ParseIntError { kind: Empty }),
-                }
+#[doc(hidden)]
+trait FromStrRadixHelper: PartialOrd + Copy {
+    fn min_value() -> Self;
+    fn from_u32(u: u32) -> Self;
+    fn checked_mul(&self, other: u32) -> Option<Self>;
+    fn checked_sub(&self, other: u32) -> Option<Self>;
+    fn checked_add(&self, other: u32) -> Option<Self>;
+}
+
+macro_rules! doit {
+    ($($t:ident)*) => ($(impl FromStrRadixHelper for $t {
+        fn min_value() -> Self { <$t>::min_value() }
+        fn from_u32(u: u32) -> Self { u as $t }
+        fn checked_mul(&self, other: u32) -> Option<Self> {
+            <$t>::checked_mul(*self, other as $t)
+        }
+        fn checked_sub(&self, other: u32) -> Option<Self> {
+            <$t>::checked_sub(*self, other as $t)
+        }
+        fn checked_add(&self, other: u32) -> Option<Self> {
+            <$t>::checked_add(*self, other as $t)
+        }
+    })*)
+}
+doit! { i8 i16 i32 i64 isize u8 u16 u32 u64 usize }
+
+fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32)
+                                         -> Result<T, ParseIntError> {
+    use self::IntErrorKind::*;
+    use self::ParseIntError as PIE;
+    assert!(radix >= 2 && radix <= 36,
+           "from_str_radix_int: must lie in the range `[2, 36]` - found {}",
+           radix);
+
+    let is_signed_ty = T::from_u32(0) > T::min_value();
+
+    match src.slice_shift_char() {
+        Some(('-', "")) => Err(PIE { kind: Empty }),
+        Some(('-', src)) if is_signed_ty => {
+            // The number is negative
+            let mut result = T::from_u32(0);
+            for c in src.chars() {
+                let x = match c.to_digit(radix) {
+                    Some(x) => x,
+                    None => return Err(PIE { kind: InvalidDigit }),
+                };
+                result = match result.checked_mul(radix) {
+                    Some(result) => result,
+                    None => return Err(PIE { kind: Underflow }),
+                };
+                result = match result.checked_sub(x) {
+                    Some(result) => result,
+                    None => return Err(PIE { kind: Underflow }),
+                };
             }
-        }
+            Ok(result)
+        },
+        Some((_, _)) => {
+            // The number is signed
+            let mut result = T::from_u32(0);
+            for c in src.chars() {
+                let x = match c.to_digit(radix) {
+                    Some(x) => x,
+                    None => return Err(PIE { kind: InvalidDigit }),
+                };
+                result = match result.checked_mul(radix) {
+                    Some(result) => result,
+                    None => return Err(PIE { kind: Overflow }),
+                };
+                result = match result.checked_add(x) {
+                    Some(result) => result,
+                    None => return Err(PIE { kind: Overflow }),
+                };
+            }
+            Ok(result)
+        },
+        None => Err(ParseIntError { kind: Empty }),
     }
 }
-from_str_radix_int_impl! { isize }
-from_str_radix_int_impl! { i8 }
-from_str_radix_int_impl! { i16 }
-from_str_radix_int_impl! { i32 }
-from_str_radix_int_impl! { i64 }
-from_str_radix_int_impl! { usize }
-from_str_radix_int_impl! { u8 }
-from_str_radix_int_impl! { u16 }
-from_str_radix_int_impl! { u32 }
-from_str_radix_int_impl! { u64 }
 
 /// An error which can be returned when parsing an integer.
 #[derive(Debug, Clone, PartialEq)]
@@ -3121,11 +1509,10 @@ impl fmt::Display for ParseIntError {
 
 /// An error which can be returned when parsing a float.
 #[derive(Debug, Clone, PartialEq)]
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct ParseFloatError { kind: FloatErrorKind }
+pub struct ParseFloatError { pub kind: FloatErrorKind }
 
 #[derive(Debug, Clone, PartialEq)]
-enum FloatErrorKind {
+pub enum FloatErrorKind {
     Empty,
     Invalid,
 }
diff --git a/src/libcore/num/wrapping.rs b/src/libcore/num/wrapping.rs
index aa84708816b..b7ca497db18 100644
--- a/src/libcore/num/wrapping.rs
+++ b/src/libcore/num/wrapping.rs
@@ -15,8 +15,6 @@ use super::Wrapping;
 
 use ops::*;
 
-use intrinsics::{overflowing_add, overflowing_sub, overflowing_mul};
-
 use intrinsics::{i8_add_with_overflow, u8_add_with_overflow};
 use intrinsics::{i16_add_with_overflow, u16_add_with_overflow};
 use intrinsics::{i32_add_with_overflow, u32_add_with_overflow};
@@ -33,14 +31,6 @@ use intrinsics::{i64_mul_with_overflow, u64_mul_with_overflow};
 use ::{i8,i16,i32,i64};
 
 #[unstable(feature = "core", reason = "may be removed, renamed, or relocated")]
-#[deprecated(since = "1.0.0", reason = "moved to inherent methods")]
-pub trait WrappingOps {
-    fn wrapping_add(self, rhs: Self) -> Self;
-    fn wrapping_sub(self, rhs: Self) -> Self;
-    fn wrapping_mul(self, rhs: Self) -> Self;
-}
-
-#[unstable(feature = "core", reason = "may be removed, renamed, or relocated")]
 pub trait OverflowingOps {
     fn overflowing_add(self, rhs: Self) -> (Self, bool);
     fn overflowing_sub(self, rhs: Self) -> (Self, bool);
@@ -99,27 +89,6 @@ sh_impl_all! { u8 u16 u32 u64 usize i8 i16 i32 i64 isize }
 
 macro_rules! wrapping_impl {
     ($($t:ty)*) => ($(
-        impl WrappingOps for $t {
-            #[inline(always)]
-            fn wrapping_add(self, rhs: $t) -> $t {
-                unsafe {
-                    overflowing_add(self, rhs)
-                }
-            }
-            #[inline(always)]
-            fn wrapping_sub(self, rhs: $t) -> $t {
-                unsafe {
-                    overflowing_sub(self, rhs)
-                }
-            }
-            #[inline(always)]
-            fn wrapping_mul(self, rhs: $t) -> $t {
-                unsafe {
-                    overflowing_mul(self, rhs)
-                }
-            }
-        }
-
         #[stable(feature = "rust1", since = "1.0.0")]
         impl Add for Wrapping<$t> {
             type Output = Wrapping<$t>;
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index 4c784a579da..d1bc24bd9ba 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -551,25 +551,6 @@ impl<T> Option<T> {
         IterMut { inner: Item { opt: self.as_mut() } }
     }
 
-    /// Returns a consuming iterator over the possibly contained value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let x = Some("string");
-    /// let v: Vec<&str> = x.into_iter().collect();
-    /// assert_eq!(v, ["string"]);
-    ///
-    /// let x = None;
-    /// let v: Vec<&str> = x.into_iter().collect();
-    /// assert!(v.is_empty());
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn into_iter(self) -> IntoIter<T> {
-        IntoIter { inner: Item { opt: self } }
-    }
-
     /////////////////////////////////////////////////////////////////////////
     // Boolean operations on the values, eager and lazy
     /////////////////////////////////////////////////////////////////////////
@@ -770,6 +751,30 @@ impl<T> Default for Option<T> {
     fn default() -> Option<T> { None }
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T> IntoIterator for Option<T> {
+    type Item = T;
+    type IntoIter = IntoIter<T>;
+
+    /// Returns a consuming iterator over the possibly contained value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// let x = Some("string");
+    /// let v: Vec<&str> = x.into_iter().collect();
+    /// assert_eq!(v, ["string"]);
+    ///
+    /// let x = None;
+    /// let v: Vec<&str> = x.into_iter().collect();
+    /// assert!(v.is_empty());
+    /// ```
+    #[inline]
+    fn into_iter(self) -> IntoIter<T> {
+        IntoIter { inner: Item { opt: self } }
+    }
+}
+
 /////////////////////////////////////////////////////////////////////////////
 // The Option Iterators
 /////////////////////////////////////////////////////////////////////////////
diff --git a/src/libcore/prelude.rs b/src/libcore/prelude.rs
index e60bc494081..a4d529ad47d 100644
--- a/src/libcore/prelude.rs
+++ b/src/libcore/prelude.rs
@@ -37,11 +37,10 @@ pub use char::CharExt;
 pub use clone::Clone;
 pub use cmp::{PartialEq, PartialOrd, Eq, Ord};
 pub use convert::{AsRef, AsMut, Into, From};
+pub use default::Default;
+pub use iter::IntoIterator;
 pub use iter::{Iterator, DoubleEndedIterator, Extend, ExactSizeIterator};
 pub use option::Option::{self, Some, None};
 pub use result::Result::{self, Ok, Err};
 pub use slice::SliceExt;
 pub use str::StrExt;
-
-#[allow(deprecated)] pub use slice::AsSlice;
-#[allow(deprecated)] pub use str::Str;
diff --git a/src/libcore/result.rs b/src/libcore/result.rs
index 03894926293..e909946ece4 100644
--- a/src/libcore/result.rs
+++ b/src/libcore/result.rs
@@ -234,8 +234,6 @@ use fmt;
 use iter::{Iterator, DoubleEndedIterator, FromIterator, ExactSizeIterator, IntoIterator};
 use ops::{FnMut, FnOnce};
 use option::Option::{self, None, Some};
-#[allow(deprecated)]
-use slice::AsSlice;
 use slice;
 
 /// `Result` is a type that represents either success (`Ok`) or failure (`Err`).
@@ -547,25 +545,6 @@ impl<T, E> Result<T, E> {
         IterMut { inner: self.as_mut().ok() }
     }
 
-    /// Returns a consuming iterator over the possibly contained value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let x: Result<u32, &str> = Ok(5);
-    /// let v: Vec<u32> = x.into_iter().collect();
-    /// assert_eq!(v, [5]);
-    ///
-    /// let x: Result<u32, &str> = Err("nothing!");
-    /// let v: Vec<u32> = x.into_iter().collect();
-    /// assert_eq!(v, []);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn into_iter(self) -> IntoIter<T> {
-        IntoIter { inner: self.ok() }
-    }
-
     ////////////////////////////////////////////////////////////////////////
     // Boolean operations on the values, eager and lazy
     /////////////////////////////////////////////////////////////////////////
@@ -787,23 +766,27 @@ impl<T: fmt::Debug, E> Result<T, E> {
 // Trait implementations
 /////////////////////////////////////////////////////////////////////////////
 
-#[unstable(feature = "core",
-           reason = "waiting on the stability of the trait itself")]
-#[deprecated(since = "1.0.0",
-             reason = "use inherent method instead")]
-#[allow(deprecated)]
-impl<T, E> AsSlice<T> for Result<T, E> {
-    /// Converts from `Result<T, E>` to `&[T]` (without copying)
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T, E> IntoIterator for Result<T, E> {
+    type Item = T;
+    type IntoIter = IntoIter<T>;
+
+    /// Returns a consuming iterator over the possibly contained value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// let x: Result<u32, &str> = Ok(5);
+    /// let v: Vec<u32> = x.into_iter().collect();
+    /// assert_eq!(v, [5]);
+    ///
+    /// let x: Result<u32, &str> = Err("nothing!");
+    /// let v: Vec<u32> = x.into_iter().collect();
+    /// assert_eq!(v, []);
+    /// ```
     #[inline]
-    fn as_slice<'a>(&'a self) -> &'a [T] {
-        match *self {
-            Ok(ref x) => slice::ref_slice(x),
-            Err(_) => {
-                // work around lack of implicit coercion from fixed-size array to slice
-                let emp: &[_] = &[];
-                emp
-            }
-        }
+    fn into_iter(self) -> IntoIter<T> {
+        IntoIter { inner: self.ok() }
     }
 }
 
diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
index 4b1742a4348..1e96d761d40 100644
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@@ -51,7 +51,7 @@ use result::Result::{Ok, Err};
 use ptr;
 use mem;
 use mem::size_of;
-use marker::{Send, Sized, Sync, self};
+use marker::{Send, Sync, self};
 use raw::Repr;
 // Avoid conflicts with *both* the Slice trait (buggy) and the `slice::raw` module.
 use raw::Slice as RawSlice;
@@ -595,37 +595,6 @@ impl<T> ops::IndexMut<RangeFull> for [T] {
 // Common traits
 ////////////////////////////////////////////////////////////////////////////////
 
-/// Data that is viewable as a slice.
-#[unstable(feature = "core",
-           reason = "will be replaced by slice syntax")]
-#[deprecated(since = "1.0.0",
-             reason = "use std::convert::AsRef<[T]> instead")]
-pub trait AsSlice<T> {
-    /// Work with `self` as a slice.
-    fn as_slice<'a>(&'a self) -> &'a [T];
-}
-
-#[unstable(feature = "core", reason = "trait is experimental")]
-#[allow(deprecated)]
-impl<T> AsSlice<T> for [T] {
-    #[inline(always)]
-    fn as_slice<'a>(&'a self) -> &'a [T] { self }
-}
-
-#[unstable(feature = "core", reason = "trait is experimental")]
-#[allow(deprecated)]
-impl<'a, T, U: ?Sized + AsSlice<T>> AsSlice<T> for &'a U {
-    #[inline(always)]
-    fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) }
-}
-
-#[unstable(feature = "core", reason = "trait is experimental")]
-#[allow(deprecated)]
-impl<'a, T, U: ?Sized + AsSlice<T>> AsSlice<T> for &'a mut U {
-    #[inline(always)]
-    fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, T> Default for &'a [T] {
     #[stable(feature = "rust1", since = "1.0.0")]
diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
index 9c3ab001187..4d343ea0f1e 100644
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -25,7 +25,6 @@ use default::Default;
 use fmt;
 use iter::ExactSizeIterator;
 use iter::{Map, Iterator, DoubleEndedIterator};
-use marker::Sized;
 use mem;
 use ops::{Fn, FnMut, FnOnce};
 use option::Option::{self, None, Some};
@@ -1463,30 +1462,6 @@ mod traits {
     }
 }
 
-/// Any string that can be represented as a slice
-#[unstable(feature = "core",
-           reason = "Instead of taking this bound generically, this trait will be \
-                     replaced with one of slicing syntax (&foo[..]), deref coercions, or \
-                     a more generic conversion trait")]
-#[deprecated(since = "1.0.0",
-             reason = "use std::convert::AsRef<str> instead")]
-pub trait Str {
-    /// Work with `self` as a slice.
-    fn as_slice<'a>(&'a self) -> &'a str;
-}
-
-#[allow(deprecated)]
-impl Str for str {
-    #[inline]
-    fn as_slice<'a>(&'a self) -> &'a str { self }
-}
-
-#[allow(deprecated)]
-impl<'a, S: ?Sized> Str for &'a S where S: Str {
-    #[inline]
-    fn as_slice(&self) -> &str { Str::as_slice(*self) }
-}
-
 /// Methods for string slices
 #[allow(missing_docs)]
 #[doc(hidden)]