---

yaml
---
r: 113661
b: refs/heads/snap-stage3
c: a211907
h: refs/heads/master
i:
  113659: 9a8a3a9
v: v3

Author: aturon

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: abdacecdf86b4b5a4f432560445a24e1c5f4751b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 1ba7bd10c9c537687ca393eca0b323569309b83a
+refs/heads/snap-stage3: a211907f88a8ac7a7deb3bd4c028e5dd34be95a2
 refs/heads/try: 7c6c492fb2af9a85f21ff952942df3523b22fd17
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/doc/rust.md

@@ -2943,7 +2943,7 @@ See [Break expressions](#break-expressions) and [Continue expressions](#continue
 break_expr : "break" [ lifetime ];
 ~~~~
 
-A `break` expression has an optional _label_.
+A `break` expression has an optional `label`.
 If the label is absent, then executing a `break` expression immediately terminates the innermost loop enclosing it.
 It is only permitted in the body of a loop.
 If the label is present, then `break foo` terminates the loop with label `foo`,
@@ -2956,7 +2956,7 @@ but must enclose it.
 continue_expr : "continue" [ lifetime ];
 ~~~~
 
-A `continue` expression has an optional _label_.
+A `continue` expression has an optional `label`.
 If the label is absent,
 then executing a `continue` expression immediately terminates the current iteration of the innermost loop enclosing it,
 returning control to the loop *head*.
@@ -3115,7 +3115,7 @@ let x: List<int> = Cons(10, box Cons(11, box Nil));
 
 match x {
     Cons(a, box Cons(b, _)) => {
-        process_pair(a, b);
+        process_pair(a,b);
     }
     Cons(10, _) => {
         process_ten();
@@ -3329,8 +3329,8 @@ order specified by the tuple type.
 An example of a tuple type and its use:
 
 ~~~~
-type Pair<'a> = (int, &'a str);
-let p: Pair<'static> = (10, "hello");
+type Pair<'a> = (int,&'a str);
+let p: Pair<'static> = (10,"hello");
 let (a, b) = p;
 assert!(b != "world");
 ~~~~

branches/snap-stage3/src/doc/tutorial.md

@@ -2602,7 +2602,7 @@ fn main() {
 ~~~
 
 The full list of derivable traits is `Eq`, `TotalEq`, `Ord`,
-`TotalOrd`, `Encodable`, `Decodable`, `Clone`,
+`TotalOrd`, `Encodable` `Decodable`, `Clone`,
 `Hash`, `Rand`, `Default`, `Zero`, `FromPrimitive` and `Show`.
 
 # Crates and the module system

branches/snap-stage3/src/libcollections/bitv.rs

@@ -486,17 +486,13 @@ impl Bitv {
         !self.none()
     }
 
-    pub fn init_to_vec(&self, i: uint) -> uint {
-      return if self.get(i) { 1 } else { 0 };
-    }
-
     /**
      * Converts `self` to a vector of `uint` with the same length.
      *
      * Each `uint` in the resulting vector has either value `0u` or `1u`.
      */
     pub fn to_vec(&self) -> Vec<uint> {
-        Vec::from_fn(self.nbits, |x| self.init_to_vec(x))
+        Vec::from_fn(self.nbits, |i| if self.get(i) { 1 } else { 0 })
     }
 
     /**

branches/snap-stage3/src/libcore/bool.rs

@@ -15,14 +15,11 @@
 //! Implementations of the following traits:
 //!
 //! * `Not`
-//! * `BitAnd`
-//! * `BitOr`
-//! * `BitXor`
 //! * `Ord`
 //! * `TotalOrd`
 //! * `Eq`
-//! * `TotalEq`
 //! * `Default`
+//! * `Zero`
 //!
 //! A `to_bit` conversion function.
 

branches/snap-stage3/src/libcore/lib.rs

@@ -17,7 +17,7 @@
 //!
 //! * `memcpy`, `memcmp`, `memset` - These are core memory routines which are
 //!   often generated by LLVM. Additionally, this library can make explicit
-//!   calls to these functions. Their signatures are the same as found in C.
+//!   calls to these funcitons. Their signatures are the same as found in C.
 //!   These functions are often provided by the system libc, but can also be
 //!   provided by `librlibc` which is distributed with the standard rust
 //!   distribution.

branches/snap-stage3/src/libcore/num/mod.rs

@@ -11,7 +11,7 @@
 //! Numeric traits and functions for generic mathematics
 //!
 //! These are implemented for the primitive numeric types in `std::{u8, u16,
-//! u32, u64, uint, i8, i16, i32, i64, int, f32, f64}`.
+//! u32, u64, uint, i8, i16, i32, i64, int, f32, f64, float}`.
 
 #![allow(missing_doc)]
 
@@ -97,7 +97,7 @@ pub trait One: Mul<Self, Self> {
 pub trait Signed: Num + Neg<Self> {
     /// Computes the absolute value.
     ///
-    /// For `f32` and `f64`, `NaN` will be returned if the number is `NaN`.
+    /// For float, f32, and f64, `NaN` will be returned if the number is `NaN`.
     fn abs(&self) -> Self;
 
     /// The positive difference of two numbers.
@@ -108,17 +108,15 @@ pub trait Signed: Num + Neg<Self> {
 
     /// Returns the sign of the number.
     ///
-    /// For `f32` and `f64`:
-    ///
-    /// * `1.0` if the number is positive, `+0.0` or `INFINITY`
-    /// * `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
-    /// * `NaN` if the number is `NaN`
+    /// For `float`, `f32`, `f64`:
+    ///   * `1.0` if the number is positive, `+0.0` or `INFINITY`
+    ///   * `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
+    ///   * `NaN` if the number is `NaN`
     ///
     /// For `int`:
-    ///
-    /// * `0` if the number is zero
-    /// * `1` if the number is positive
-    /// * `-1` if the number is negative
+    ///   * `0` if the number is zero
+    ///   * `1` if the number is positive
+    ///   * `-1` if the number is negative
     fn signum(&self) -> Self;
 
     /// Returns true if the number is positive and false if the number is zero or negative.
@@ -130,7 +128,7 @@ pub trait Signed: Num + Neg<Self> {
 
 /// Computes the absolute value.
 ///
-/// For `f32` and `f64`, `NaN` will be returned if the number is `NaN`
+/// For float, f32, and f64, `NaN` will be returned if the number is `NaN`
 #[inline(always)]
 pub fn abs<T: Signed>(value: T) -> T {
     value.abs()
@@ -147,17 +145,15 @@ pub fn abs_sub<T: Signed>(x: T, y: T) -> T {
 
 /// Returns the sign of the number.
 ///
-/// For `f32` and `f64`:
-///
-/// * `1.0` if the number is positive, `+0.0` or `INFINITY`
-/// * `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
-/// * `NaN` if the number is `NaN`
+/// For float, f32, f64:
+/// - `1.0` if the number is positive, `+0.0` or `INFINITY`
+/// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
+/// - `NAN` if the number is `NAN`
 ///
 /// For int:
-///
-/// * `0` if the number is zero
-/// * `1` if the number is positive
-/// * `-1` if the number is negative
+/// - `0` if the number is zero
+/// - `1` if the number is positive
+/// - `-1` if the number is negative
 #[inline(always)] pub fn signum<T: Signed>(value: T) -> T { value.signum() }
 
 /// A trait for values which cannot be negative

branches/snap-stage3/src/libcore/result.rs

@@ -508,19 +508,12 @@ impl<T, E> Result<T, E> {
     /// Unwraps a result, yielding the content of an `Ok`.
     /// If the value is an `Err` then it calls `op` with its value.
     #[inline]
-    pub fn unwrap_or_else(self, op: |E| -> T) -> T {
+    pub fn unwrap_or_handle(self, op: |E| -> T) -> T {
         match self {
             Ok(t) => t,
             Err(e) => op(e)
         }
     }
-
-    /// Deprecated name for `unwrap_or_else()`.
-    #[deprecated = "replaced by .unwrap_or_else()"]
-    #[inline]
-    pub fn unwrap_or_handle(self, op: |E| -> T) -> T {
-        self.unwrap_or_else(op)
-    }
 }
 
 impl<T, E: Show> Result<T, E> {
@@ -765,8 +758,8 @@ mod tests {
         let ok: Result<int, ~str> = Ok(100);
         let ok_err: Result<int, ~str> = Err("I got this.".to_owned());
 
-        assert_eq!(ok.unwrap_or_else(handler), 100);
-        assert_eq!(ok_err.unwrap_or_else(handler), 50);
+        assert_eq!(ok.unwrap_or_handle(handler), 100);
+        assert_eq!(ok_err.unwrap_or_handle(handler), 50);
     }
 
     #[test]
@@ -781,6 +774,6 @@ mod tests {
         }
 
         let bad_err: Result<int, ~str> = Err("Unrecoverable mess.".to_owned());
-        let _ : int = bad_err.unwrap_or_else(handler);
+        let _ : int = bad_err.unwrap_or_handle(handler);
     }
 }

branches/snap-stage3/src/libstd/num/mod.rs

@@ -11,7 +11,7 @@
 //! Numeric traits and functions for generic mathematics
 //!
 //! These are implemented for the primitive numeric types in `std::{u8, u16,
-//! u32, u64, uint, i8, i16, i32, i64, int, f32, f64}`.
+//! u32, u64, uint, i8, i16, i32, i64, int, f32, f64, float}`.
 
 #![allow(missing_doc)]
 

branches/snap-stage3/src/libtest/lib.rs

@@ -32,7 +32,7 @@
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://static.rust-lang.org/doc/master")]
 
-#![feature(asm, macro_rules, phase)]
+#![feature(asm, macro_rules)]
 #![deny(deprecated_owned_vector)]
 
 extern crate collections;
@@ -83,7 +83,7 @@ pub mod stats;
 // colons. This way if some test runner wants to arrange the tests
 // hierarchically it may.
 
-#[deriving(Clone, Eq, TotalEq, Hash)]
+#[deriving(Clone)]
 pub enum TestName {
     StaticTestName(&'static str),
     DynTestName(StrBuf)
@@ -156,19 +156,6 @@ impl TestFn {
     }
 }
 
-impl fmt::Show for TestFn {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write(match *self {
-            StaticTestFn(..) => "StaticTestFn(..)",
-            StaticBenchFn(..) => "StaticBenchFn(..)",
-            StaticMetricFn(..) => "StaticMetricFn(..)",
-            DynTestFn(..) => "DynTestFn(..)",
-            DynMetricFn(..) => "DynMetricFn(..)",
-            DynBenchFn(..) => "DynBenchFn(..)"
-        }.as_bytes())
-    }
-}
-
 /// Manager of the benchmarking runs.
 ///
 /// This is feed into functions marked with `#[bench]` to allow for
@@ -183,14 +170,13 @@ pub struct Bencher {
 
 // The definition of a single test. A test runner will run a list of
 // these.
-#[deriving(Clone, Show, Eq, TotalEq, Hash)]
+#[deriving(Clone)]
 pub struct TestDesc {
     pub name: TestName,
     pub ignore: bool,
     pub should_fail: bool,
 }
 
-#[deriving(Show)]
 pub struct TestDescAndFn {
     pub desc: TestDesc,
     pub testfn: TestFn,
@@ -256,9 +242,15 @@ pub fn test_main(args: &[StrBuf], tests: Vec<TestDescAndFn> ) {
 pub fn test_main_static(args: &[StrBuf], tests: &[TestDescAndFn]) {
     let owned_tests = tests.iter().map(|t| {
         match t.testfn {
-            StaticTestFn(f) => TestDescAndFn { testfn: StaticTestFn(f), desc: t.desc.clone() },
-            StaticBenchFn(f) => TestDescAndFn { testfn: StaticBenchFn(f), desc: t.desc.clone() },
-            _ => fail!("non-static tests passed to test::test_main_static")
+            StaticTestFn(f) =>
+            TestDescAndFn { testfn: StaticTestFn(f), desc: t.desc.clone() },
+
+            StaticBenchFn(f) =>
+            TestDescAndFn { testfn: StaticBenchFn(f), desc: t.desc.clone() },
+
+            _ => {
+                fail!("non-static tests passed to test::test_main_static");
+            }
         }
     }).collect();
     test_main(args, owned_tests)
@@ -427,15 +419,8 @@ pub fn opt_shard(maybestr: Option<StrBuf>) -> Option<(uint,uint)> {
         None => None,
         Some(s) => {
             let mut it = s.as_slice().split('.');
-            match (it.next().and_then(from_str::<uint>), it.next().and_then(from_str::<uint>),
-                   it.next()) {
-                (Some(a), Some(b), None) => {
-                    if a <= 0 || a > b {
-                        fail!("tried to run shard {a}.{b}, but {a} is out of bounds \
-                              (should be between 1 and {b}", a=a, b=b)
-                    }
-                    Some((a, b))
-                }
+            match (it.next().and_then(from_str), it.next().and_then(from_str), it.next()) {
+                (Some(a), Some(b), None) => Some((a, b)),
                 _ => None,
             }
         }
@@ -754,9 +739,10 @@ pub fn fmt_bench_samples(bs: &BenchSamples) -> StrBuf {
 }
 
 // A simple console test runner
-pub fn run_tests_console(opts: &TestOpts, tests: Vec<TestDescAndFn> ) -> io::IoResult<bool> {
-
-    fn callback<T: Writer>(event: &TestEvent, st: &mut ConsoleTestState<T>) -> io::IoResult<()> {
+pub fn run_tests_console(opts: &TestOpts,
+                         tests: Vec<TestDescAndFn> ) -> io::IoResult<bool> {
+    fn callback<T: Writer>(event: &TestEvent,
+                           st: &mut ConsoleTestState<T>) -> io::IoResult<()> {
         match (*event).clone() {
             TeFiltered(ref filtered_tests) => st.write_run_start(filtered_tests.len()),
             TeWait(ref test, padding) => st.write_test_start(test, padding),
@@ -792,7 +778,6 @@ pub fn run_tests_console(opts: &TestOpts, tests: Vec<TestDescAndFn> ) -> io::IoR
             }
         }
     }
-
     let mut st = try!(ConsoleTestState::new(opts, None::<StdWriter>));
     fn len_if_padded(t: &TestDescAndFn) -> uint {
         match t.testfn.padding() {
@@ -948,7 +933,9 @@ fn get_concurrency() -> uint {
     }
 }
 
-pub fn filter_tests(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> Vec<TestDescAndFn> {
+pub fn filter_tests(
+    opts: &TestOpts,
+    tests: Vec<TestDescAndFn> ) -> Vec<TestDescAndFn> {
     let mut filtered = tests;
 
     // Remove tests that don't match the test filter
@@ -986,9 +973,7 @@ pub fn filter_tests(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> Vec<TestDescA
         None => filtered,
         Some((a,b)) => {
             filtered.move_iter().enumerate()
-            // note: using a - 1 so that the valid shards, for example, are
-            // 1.2 and 2.2 instead of 0.2 and 1.2
-            .filter(|&(i,_)| i % b == (a - 1))
+            .filter(|&(i,_)| i % b == a)
             .map(|(_,t)| t)
             .collect()
         }