---

yaml
---
r: 60290
b: refs/heads/master
c: 4e1fac8
h: refs/heads/master
v: v3

Author: gifnksm

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 84745b483f322671f894b9e8d0a462c46275a9d3
+refs/heads/master: 4e1fac89bb3e757801735ba6220ddf756054e071
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589

trunk/src/libcore/at_vec.rs

@@ -11,10 +11,8 @@
 //! Managed vectors
 
 use cast::transmute;
-use container::Container;
 use kinds::Copy;
 use old_iter;
-use old_iter::BaseIter;
 use option::Option;
 use sys;
 use uint;

trunk/src/libcore/comm.rs

@@ -13,13 +13,12 @@ Message passing
 */
 
 use cast::{transmute, transmute_mut};
-use container::Container;
 use either::{Either, Left, Right};
 use kinds::Owned;
 use option::{Option, Some, None};
 use uint;
+use unstable;
 use vec;
-use vec::OwnedVector;
 use util::replace;
 use unstable::sync::{Exclusive, exclusive};
 
@@ -578,7 +577,7 @@ impl<T:Owned,
 #[cfg(test)]
 mod test {
     use either::Right;
-    use super::{Chan, Port, oneshot, stream};
+    use super::{Chan, Port, oneshot, recv_one, stream};
 
     #[test]
     fn test_select2() {

trunk/src/libcore/core.rc

@@ -68,6 +68,48 @@ they contained the following prologue:
 #[cfg(test)] pub use ops = realcore::ops;
 #[cfg(test)] pub use cmp = realcore::cmp;
 
+/* Reexported core operators */
+
+pub use kinds::{Const, Copy, Owned};
+pub use ops::{Drop};
+pub use ops::{Add, Sub, Mul, Div, Rem, Neg, Not};
+pub use ops::{BitAnd, BitOr, BitXor};
+pub use ops::{Shl, Shr, Index};
+
+
+/* Reexported types and traits */
+
+pub use option::{Option, Some, None};
+pub use result::{Result, Ok, Err};
+
+pub use path::Path;
+pub use path::GenericPath;
+pub use path::WindowsPath;
+pub use path::PosixPath;
+
+pub use tuple::{CopyableTuple, ImmutableTuple, ExtendedTupleOps};
+pub use str::{StrSlice};
+pub use container::{Container, Mutable};
+pub use vec::{CopyableVector, ImmutableVector};
+pub use vec::{ImmutableEqVector, ImmutableCopyableVector};
+pub use vec::{OwnedVector, OwnedCopyableVector, MutableVector};
+pub use old_iter::{BaseIter, ExtendedIter, EqIter, CopyableIter};
+pub use old_iter::{CopyableOrderedIter, CopyableNonstrictIter};
+pub use old_iter::{ExtendedMutableIter};
+pub use iter::Times;
+
+pub use num::{Num, NumCast};
+pub use num::{Orderable, Signed, Unsigned, Round};
+pub use num::{Algebraic, Trigonometric, Exponential, Hyperbolic};
+pub use num::{Integer, Fractional, Real, RealExt};
+pub use num::{Bitwise, BitCount, Bounded};
+pub use num::{Primitive, Int, Float};
+
+pub use ptr::Ptr;
+pub use from_str::FromStr;
+pub use to_str::ToStr;
+pub use clone::Clone;
+
 // On Linux, link to the runtime with -lrt.
 #[cfg(target_os = "linux")]
 #[doc(hidden)]

trunk/src/libcore/either.rs

@@ -10,14 +10,11 @@
 
 //! A type that represents one of two alternatives
 
-use container::Container;
 use cmp::Eq;
 use kinds::Copy;
-use old_iter::BaseIter;
 use result::Result;
 use result;
 use vec;
-use vec::OwnedVector;
 
 /// The either type
 #[deriving(Clone, Eq)]

trunk/src/libcore/hash.rs

@@ -21,8 +21,6 @@
 
 #[cfg(stage0)]
 use cast;
-use container::Container;
-use old_iter::BaseIter;
 use rt::io::Writer;
 use to_bytes::IterBytes;
 use uint;

trunk/src/libcore/io.rs

@@ -16,7 +16,6 @@ Basic input/output
 
 use result::Result;
 
-use container::Container;
 use int;
 use libc;
 use libc::{c_int, c_long, c_void, size_t, ssize_t};
@@ -25,15 +24,11 @@ use os;
 use cast;
 use path::Path;
 use ops::Drop;
-use old_iter::{BaseIter, CopyableIter};
 use ptr;
 use result;
 use str;
-use str::StrSlice;
-use to_str::ToStr;
 use uint;
 use vec;
-use vec::{OwnedVector, OwnedCopyableVector};
 
 #[allow(non_camel_case_types)] // not sure what to do about this
 pub type fd_t = c_int;

trunk/src/libcore/iter.rs

@@ -42,7 +42,6 @@ much easier to implement.
 
 #[cfg(not(stage0))] use cmp::Ord;
 #[cfg(not(stage0))] use option::{Option, Some, None};
-#[cfg(not(stage0))] use vec::OwnedVector;
 
 #[cfg(stage0)]
 pub trait Times {

trunk/src/libcore/logging.rs

@@ -45,7 +45,6 @@ pub fn console_off() {
 #[cfg(not(test))]
 #[lang="log_type"]
 pub fn log_type<T>(level: u32, object: &T) {
-    use container::Container;
     use cast::transmute;
     use io;
     use libc;

trunk/src/libcore/num/f32.rs

@@ -10,7 +10,6 @@
 
 //! Operations and constants for `f32`
 
-use libc::c_int;
 use num::{Zero, One, strconv};
 use num::{FPCategory, FPNaN, FPInfinite , FPZero, FPSubnormal, FPNormal};
 use prelude::*;
@@ -451,57 +450,6 @@ impl Hyperbolic for f32 {
 
     #[inline(always)]
     fn tanh(&self) -> f32 { tanh(*self) }
-
-    ///
-    /// Inverse hyperbolic sine
-    ///
-    /// # Returns
-    ///
-    /// - on success, the inverse hyperbolic sine of `self` will be returned
-    /// - `self` if `self` is `0.0`, `-0.0`, `infinity`, or `neg_infinity`
-    /// - `NaN` if `self` is `NaN`
-    ///
-    #[inline(always)]
-    fn asinh(&self) -> f32 {
-        match *self {
-            neg_infinity => neg_infinity,
-            x => (x + ((x * x) + 1.0).sqrt()).ln(),
-        }
-    }
-
-    ///
-    /// Inverse hyperbolic cosine
-    ///
-    /// # Returns
-    ///
-    /// - on success, the inverse hyperbolic cosine of `self` will be returned
-    /// - `infinity` if `self` is `infinity`
-    /// - `NaN` if `self` is `NaN` or `self < 1.0` (including `neg_infinity`)
-    ///
-    #[inline(always)]
-    fn acosh(&self) -> f32 {
-        match *self {
-            x if x < 1.0 => Float::NaN(),
-            x => (x + ((x * x) - 1.0).sqrt()).ln(),
-        }
-    }
-
-    ///
-    /// Inverse hyperbolic tangent
-    ///
-    /// # Returns
-    ///
-    /// - on success, the inverse hyperbolic tangent of `self` will be returned
-    /// - `self` if `self` is `0.0` or `-0.0`
-    /// - `infinity` if `self` is `1.0`
-    /// - `neg_infinity` if `self` is `-1.0`
-    /// - `NaN` if the `self` is `NaN` or outside the domain of `-1.0 <= self <= 1.0`
-    ///   (including `infinity` and `neg_infinity`)
-    ///
-    #[inline(always)]
-    fn atanh(&self) -> f32 {
-        0.5 * ((2.0 * *self) / (1.0 - *self)).ln_1p()
-    }
 }
 
 impl Real for f32 {
@@ -672,25 +620,6 @@ impl Float for f32 {
     #[inline(always)]
     fn max_10_exp() -> int { 38 }
 
-    /// Constructs a floating point number by multiplying `x` by 2 raised to the power of `exp`
-    #[inline(always)]
-    fn ldexp(x: f32, exp: int) -> f32 {
-        ldexp(x, exp as c_int)
-    }
-
-    ///
-    /// Breaks the number into a normalized fraction and a base-2 exponent, satisfying:
-    ///
-    /// - `self = x * pow(2, exp)`
-    /// - `0.5 <= abs(x) < 1.0`
-    ///
-    #[inline(always)]
-    fn frexp(&self) -> (f32, int) {
-        let mut exp = 0;
-        let x = frexp(*self, &mut exp);
-        (x, exp as int)
-    }
-
     ///
     /// Returns the exponential of the number, minus `1`, in a way that is accurate
     /// even if the number is close to zero
@@ -1043,43 +972,6 @@ mod tests {
         assert_approx_eq!((-1.7f32).fract(), -0.7f32);
     }
 
-    #[test]
-    fn test_asinh() {
-        assert_eq!(0.0f32.asinh(), 0.0f32);
-        assert_eq!((-0.0f32).asinh(), -0.0f32);
-        assert_eq!(Float::infinity::<f32>().asinh(), Float::infinity::<f32>());
-        assert_eq!(Float::neg_infinity::<f32>().asinh(), Float::neg_infinity::<f32>());
-        assert!(Float::NaN::<f32>().asinh().is_NaN());
-        assert_approx_eq!(2.0f32.asinh(), 1.443635475178810342493276740273105f32);
-        assert_approx_eq!((-2.0f32).asinh(), -1.443635475178810342493276740273105f32);
-    }
-
-    #[test]
-    fn test_acosh() {
-        assert_eq!(1.0f32.acosh(), 0.0f32);
-        assert!(0.999f32.acosh().is_NaN());
-        assert_eq!(Float::infinity::<f32>().acosh(), Float::infinity::<f32>());
-        assert!(Float::neg_infinity::<f32>().acosh().is_NaN());
-        assert!(Float::NaN::<f32>().acosh().is_NaN());
-        assert_approx_eq!(2.0f32.acosh(), 1.31695789692481670862504634730796844f32);
-        assert_approx_eq!(3.0f32.acosh(), 1.76274717403908605046521864995958461f32);
-    }
-
-    #[test]
-    fn test_atanh() {
-        assert_eq!(0.0f32.atanh(), 0.0f32);
-        assert_eq!((-0.0f32).atanh(), -0.0f32);
-        assert_eq!(1.0f32.atanh(), Float::infinity::<f32>());
-        assert_eq!((-1.0f32).atanh(), Float::neg_infinity::<f32>());
-        assert!(2f64.atanh().atanh().is_NaN());
-        assert!((-2f64).atanh().atanh().is_NaN());
-        assert!(Float::infinity::<f64>().atanh().is_NaN());
-        assert!(Float::neg_infinity::<f64>().atanh().is_NaN());
-        assert!(Float::NaN::<f32>().atanh().is_NaN());
-        assert_approx_eq!(0.5f32.atanh(), 0.54930614433405484569762261846126285f32);
-        assert_approx_eq!((-0.5f32).atanh(), -0.54930614433405484569762261846126285f32);
-    }
-
     #[test]
     fn test_real_consts() {
         assert_approx_eq!(Real::two_pi::<f32>(), 2f32 * Real::pi::<f32>());
@@ -1199,44 +1091,4 @@ mod tests {
         assert_eq!(1e-37f32.classify(), FPNormal);
         assert_eq!(1e-38f32.classify(), FPSubnormal);
     }
-
-    #[test]
-    fn test_ldexp() {
-        // We have to use from_str until base-2 exponents
-        // are supported in floating-point literals
-        let f1: f32 = from_str_hex("1p-123").unwrap();
-        let f2: f32 = from_str_hex("1p-111").unwrap();
-        assert_eq!(Float::ldexp(1f32, -123), f1);
-        assert_eq!(Float::ldexp(1f32, -111), f2);
-
-        assert_eq!(Float::ldexp(0f32, -123), 0f32);
-        assert_eq!(Float::ldexp(-0f32, -123), -0f32);
-        assert_eq!(Float::ldexp(Float::infinity::<f32>(), -123),
-                   Float::infinity::<f32>());
-        assert_eq!(Float::ldexp(Float::neg_infinity::<f32>(), -123),
-                   Float::neg_infinity::<f32>());
-        assert!(Float::ldexp(Float::NaN::<f32>(), -123).is_NaN());
-    }
-
-    #[test]
-    fn test_frexp() {
-        // We have to use from_str until base-2 exponents
-        // are supported in floating-point literals
-        let f1: f32 = from_str_hex("1p-123").unwrap();
-        let f2: f32 = from_str_hex("1p-111").unwrap();
-        let (x1, exp1) = f1.frexp();
-        let (x2, exp2) = f2.frexp();
-        assert_eq!((x1, exp1), (0.5f32, -122));
-        assert_eq!((x2, exp2), (0.5f32, -110));
-        assert_eq!(Float::ldexp(x1, exp1), f1);
-        assert_eq!(Float::ldexp(x2, exp2), f2);
-
-        assert_eq!(0f32.frexp(), (0f32, 0));
-        assert_eq!((-0f32).frexp(), (-0f32, 0));
-        assert_eq!(match Float::infinity::<f32>().frexp() { (x, _) => x },
-                   Float::infinity::<f32>())
-        assert_eq!(match Float::neg_infinity::<f32>().frexp() { (x, _) => x },
-                   Float::neg_infinity::<f32>())
-        assert!(match Float::NaN::<f32>().frexp() { (x, _) => x.is_NaN() })
-    }
 }