---

yaml
---
r: 151151
b: refs/heads/try2
c: 550c87e
h: refs/heads/master
i:
  151149: 0dcf325
  151147: 44a7b0f
  151143: 0d379bb
  151135: e54df38
v: v3

Author: ryantm

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 8b24964012cffda83deb7749fdddd047a4144df4
+refs/heads/try2: 550c87e17dff0ff7f87a2b4c33fe25b16707e4f6
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/complement-lang-faq.md

@@ -22,8 +22,8 @@ Some examples that demonstrate different aspects of the language:
 
 [sprocketnes]: https://github.com/pcwalton/sprocketnes
 [hash]: https://github.com/mozilla/rust/blob/master/src/libstd/hash.rs
-[HashMap]: https://github.com/mozilla/rust/blob/master/src/libcollections/hashmap.rs
-[json]: https://github.com/mozilla/rust/blob/master/src/libserialize/json.rs
+[HashMap]: https://github.com/mozilla/rust/blob/master/src/libstd/hashmap.rs
+[json]: https://github.com/mozilla/rust/blob/master/src/libextra/json.rs
 
 You may also be interested in browsing [GitHub's Rust][github-rust] page.
 

branches/try2/src/libnum/bigint.rs

@@ -230,7 +230,8 @@ impl Sub<BigUint, BigUint> for BigUint {
             lo
         }).collect();
 
-        assert_eq!(borrow, 0);     // <=> assert!((self >= other));
+        assert!(borrow == 0,
+                "Cannot subtract other from self because other is larger than self.");
         return BigUint::new(diff);
     }
 }
@@ -1755,6 +1756,13 @@ mod biguint_tests {
         }
     }
 
+    #[test]
+    #[should_fail]
+    fn test_sub_fail_on_underflow() {
+        let (a, b) : (BigUint, BigUint) = (Zero::zero(), One::one());
+        a - b;
+    }
+
     static mul_triples: &'static [(&'static [BigDigit],
                                    &'static [BigDigit],
                                    &'static [BigDigit])] = &[

branches/try2/src/libstd/io/mod.rs

@@ -1408,21 +1408,7 @@ pub fn standard_error(kind: IoErrorKind) -> IoError {
         EndOfFile => "end of file",
         IoUnavailable => "I/O is unavailable",
         InvalidInput => "invalid input",
-        OtherIoError => "unknown I/O error",
-        FileNotFound => "file not found",
-        PermissionDenied => "permission denied",
-        ConnectionFailed => "connection failed",
-        Closed => "stream is closed",
-        ConnectionRefused => "connection refused",
-        ConnectionReset => "connection reset",
-        ConnectionAborted => "connection aborted",
-        NotConnected => "not connected",
-        BrokenPipe => "broken pipe",
-        PathAlreadyExists => "file exists",
-        PathDoesntExist => "no such file",
-        MismatchedFileTypeForOperation => "mismatched file type",
-        ResourceUnavailable => "resource unavailable",
-        TimedOut => "operation timed out"
+        _ => fail!()
     };
     IoError {
         kind: kind,

branches/try2/src/libstd/iter.rs

@@ -306,7 +306,7 @@ pub trait Iterator<A> {
         Take{iter: self, n: n}
     }
 
-    /// Creates a new iterator which behaves in a similar fashion to fold.
+    /// Creates a new iterator which behaves in a similar fashion to foldl.
     /// There is a state which is passed between each iteration and can be
     /// mutated as necessary. The yielded values from the closure are yielded
     /// from the Scan instance when not None.

branches/try2/src/libstd/num/int_macros.rs

@@ -234,15 +234,16 @@ impl Primitive for $T {}
 
 // String conversion functions and impl str -> num
 
-/// Parse a byte slice as a number in the given base
+/// Parse a byte slice as a number in the given base.
 ///
 /// Yields an `Option` because `buf` may or may not actually be parseable.
 ///
 /// # Examples
 ///
-/// ```
-/// let num = std::i64::parse_bytes([49,50,51,52,53,54,55,56,57], 10);
-/// assert!(num == Some(123456789));
+/// ```rust
+/// let digits = [49,50,51,52,53,54,55,56,57];
+/// let base   = 10;
+/// let num    = std::i64::parse_bytes(digits, base);
 /// ```
 #[inline]
 pub fn parse_bytes(buf: &[u8], radix: uint) -> Option<$T> {
@@ -269,16 +270,6 @@ impl FromStrRadix for $T {
 // String conversion functions and impl num -> str
 
 /// Convert to a string as a byte slice in a given base.
-///
-/// Use in place of x.to_str() when you do not need to store the string permanently
-///
-/// # Examples
-///
-/// ```
-/// std::int::to_str_bytes(123, 10, |v| {
-///     assert!(v == "123".as_bytes());
-/// });
-/// ```
 #[inline]
 pub fn to_str_bytes<U>(n: $T, radix: uint, f: |v: &[u8]| -> U) -> U {
     // The radix can be as low as 2, so we need at least 64 characters for a

branches/try2/src/libstd/num/uint_macros.rs

@@ -148,15 +148,16 @@ impl Int for $T {}
 
 // String conversion functions and impl str -> num
 
-/// Parse a byte slice as a number in the given base
+/// Parse a byte slice as a number in the given base.
 ///
 /// Yields an `Option` because `buf` may or may not actually be parseable.
 ///
 /// # Examples
 ///
-/// ```
-/// let num = std::uint::parse_bytes([49,50,51,52,53,54,55,56,57], 10);
-/// assert!(num == Some(123456789));
+/// ```rust
+/// let digits = [49,50,51,52,53,54,55,56,57];
+/// let base   = 10;
+/// let num    = std::i64::parse_bytes(digits, base);
 /// ```
 #[inline]
 pub fn parse_bytes(buf: &[u8], radix: uint) -> Option<$T> {
@@ -183,16 +184,6 @@ impl FromStrRadix for $T {
 // String conversion functions and impl num -> str
 
 /// Convert to a string as a byte slice in a given base.
-///
-/// Use in place of x.to_str() when you do not need to store the string permanently
-///
-/// # Examples
-///
-/// ```
-/// std::uint::to_str_bytes(123, 10, |v| {
-///     assert!(v == "123".as_bytes());
-/// });
-/// ```
 #[inline]
 pub fn to_str_bytes<U>(n: $T, radix: uint, f: |v: &[u8]| -> U) -> U {
     // The radix can be as low as 2, so we need at least 64 characters for a