---

yaml
---
r: 150462
b: refs/heads/try2
c: 129cf09
h: refs/heads/master
v: v3

Author: sfackler

[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: 361d79142a011078437559af33b8fab9b4d6e408
+refs/heads/try2: 129cf09209f457cd79e5c3cdf513fd65e488d29e
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/guide-pointers.md

@@ -332,6 +332,8 @@ sense, they're simple: just keep whatever ownership the data already has. For
 example:
 
 ~~~rust
+use std::num::sqrt;
+
 struct Point {
     x: f32,
     y: f32,
@@ -341,7 +343,7 @@ fn compute_distance(p1: &Point, p2: &Point) -> f32 {
     let x_d = p1.x - p2.x;
     let y_d = p1.y - p2.y;
 
-    (x_d * x_d + y_d * y_d).sqrt()
+    sqrt(x_d * x_d + y_d * y_d)
 }
 
 fn main() {

branches/try2/src/doc/rust.md

@@ -826,14 +826,14 @@ Use declarations support a number of convenient shortcuts:
 An example of `use` declarations:
 
 ~~~~
-use std::iter::range_step;
+use std::num::sin;
 use std::option::{Some, None};
 
 # fn foo<T>(_: T){}
 
 fn main() {
-    // Equivalent to 'std::iter::range_step(0, 10, 2);'
-    range_step(0, 10, 2);
+    // Equivalent to 'std::num::sin(1.0);'
+    sin(1.0);
 
     // Equivalent to 'foo(~[std::option::Some(1.0), std::option::None]);'
     foo(~[Some(1.0), None]);

branches/try2/src/doc/tutorial.md

@@ -504,12 +504,13 @@ matching in order to bind names to the contents of data types.
 
 ~~~~
 use std::f64;
+use std::num::atan;
 fn angle(vector: (f64, f64)) -> f64 {
     let pi = f64::consts::PI;
     match vector {
       (0.0, y) if y < 0.0 => 1.5 * pi,
       (0.0, _) => 0.5 * pi,
-      (x, y) => (y / x).atan()
+      (x, y) => atan(y / x)
     }
 }
 ~~~~
@@ -1429,11 +1430,12 @@ bad, but often copies are expensive. So we’d like to define a function
 that takes the points by pointer. We can use references to do this:
 
 ~~~
+use std::num::sqrt;
 # struct Point { x: f64, y: f64 }
 fn compute_distance(p1: &Point, p2: &Point) -> f64 {
     let x_d = p1.x - p2.x;
     let y_d = p1.y - p2.y;
-    (x_d * x_d + y_d * y_d).sqrt()
+    sqrt(x_d * x_d + y_d * y_d)
 }
 ~~~
 
@@ -2301,7 +2303,7 @@ impl Shape for Circle {
     fn new(area: f64) -> Circle { Circle { radius: (area / PI).sqrt() } }
 }
 impl Shape for Square {
-    fn new(area: f64) -> Square { Square { length: area.sqrt() } }
+    fn new(area: f64) -> Square { Square { length: (area).sqrt() } }
 }
 
 let area = 42.5;

branches/try2/src/libcollections/deque.rs

@@ -52,7 +52,7 @@ pub mod bench {
                                                   map: &mut M,
                                                   bh: &mut BenchHarness) {
         // setup
-        let mut rng = rand::weak_rng();
+        let mut rng = rand::XorShiftRng::new();
 
         map.clear();
         for _ in range(0, n) {
@@ -89,7 +89,7 @@ pub mod bench {
                                                 map: &mut M,
                                                 bh: &mut BenchHarness) {
         // setup
-        let mut rng = rand::weak_rng();
+        let mut rng = rand::XorShiftRng::new();
         let mut keys = slice::from_fn(n, |_| rng.gen::<uint>() % n);
 
         for k in keys.iter() {

branches/try2/src/libgreen/sched.rs

@@ -967,12 +967,7 @@ impl ClosureConverter for UnsafeTaskReceiver {
 // worry there.
 #[cfg(windows)]
 fn new_sched_rng() -> XorShiftRng {
-    match XorShiftRng::new() {
-        Ok(r) => r,
-        Err(e) => {
-            rtabort!("sched: failed to create seeded RNG: {}", e)
-        }
-    }
+    XorShiftRng::new()
 }
 #[cfg(unix)]
 fn new_sched_rng() -> XorShiftRng {

branches/try2/src/libnative/io/addrinfo.rs

@@ -96,8 +96,10 @@ extern "system" {
 
 #[cfg(windows)]
 fn get_error(_: c_int) -> IoError {
+    use super::translate_error;
+
     unsafe {
-        IoError::from_errno(WSAGetLastError() as uint, true)
+        translate_error(WSAGetLastError() as i32, true)
     }
 }
 

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

@@ -86,10 +86,73 @@ fn unimpl() -> IoError {
     }
 }
 
-fn last_error() -> IoError {
-    IoError::last_error()
+fn translate_error(errno: i32, detail: bool) -> IoError {
+    #[cfg(windows)]
+    fn get_err(errno: i32) -> (io::IoErrorKind, &'static str) {
+        match errno {
+            libc::EOF => (io::EndOfFile, "end of file"),
+            libc::ERROR_NO_DATA => (io::BrokenPipe, "the pipe is being closed"),
+            libc::ERROR_FILE_NOT_FOUND => (io::FileNotFound, "file not found"),
+            libc::ERROR_INVALID_NAME => (io::InvalidInput, "invalid file name"),
+            libc::WSAECONNREFUSED => (io::ConnectionRefused, "connection refused"),
+            libc::WSAECONNRESET => (io::ConnectionReset, "connection reset"),
+            libc::WSAEACCES => (io::PermissionDenied, "permission denied"),
+            libc::WSAEWOULDBLOCK => {
+                (io::ResourceUnavailable, "resource temporarily unavailable")
+            }
+            libc::WSAENOTCONN => (io::NotConnected, "not connected"),
+            libc::WSAECONNABORTED => (io::ConnectionAborted, "connection aborted"),
+            libc::WSAEADDRNOTAVAIL => (io::ConnectionRefused, "address not available"),
+            libc::WSAEADDRINUSE => (io::ConnectionRefused, "address in use"),
+            libc::ERROR_BROKEN_PIPE => (io::EndOfFile, "the pipe has ended"),
+
+            // libuv maps this error code to EISDIR. we do too. if it is found
+            // to be incorrect, we can add in some more machinery to only
+            // return this message when ERROR_INVALID_FUNCTION after certain
+            // win32 calls.
+            libc::ERROR_INVALID_FUNCTION => (io::InvalidInput,
+                                             "illegal operation on a directory"),
+
+            _ => (io::OtherIoError, "unknown error")
+        }
+    }
+
+    #[cfg(not(windows))]
+    fn get_err(errno: i32) -> (io::IoErrorKind, &'static str) {
+        // FIXME: this should probably be a bit more descriptive...
+        match errno {
+            libc::EOF => (io::EndOfFile, "end of file"),
+            libc::ECONNREFUSED => (io::ConnectionRefused, "connection refused"),
+            libc::ECONNRESET => (io::ConnectionReset, "connection reset"),
+            libc::EPERM | libc::EACCES =>
+                (io::PermissionDenied, "permission denied"),
+            libc::EPIPE => (io::BrokenPipe, "broken pipe"),
+            libc::ENOTCONN => (io::NotConnected, "not connected"),
+            libc::ECONNABORTED => (io::ConnectionAborted, "connection aborted"),
+            libc::EADDRNOTAVAIL => (io::ConnectionRefused, "address not available"),
+            libc::EADDRINUSE => (io::ConnectionRefused, "address in use"),
+            libc::ENOENT => (io::FileNotFound, "no such file or directory"),
+            libc::EISDIR => (io::InvalidInput, "illegal operation on a directory"),
+
+            // These two constants can have the same value on some systems, but
+            // different values on others, so we can't use a match clause
+            x if x == libc::EAGAIN || x == libc::EWOULDBLOCK =>
+                (io::ResourceUnavailable, "resource temporarily unavailable"),
+
+            _ => (io::OtherIoError, "unknown error")
+        }
+    }
+
+    let (kind, desc) = get_err(errno);
+    IoError {
+        kind: kind,
+        desc: desc,
+        detail: if detail {Some(os::last_os_error())} else {None},
+    }
 }
 
+fn last_error() -> IoError { translate_error(os::errno() as i32, true) }
+
 // unix has nonzero values as errors
 fn mkerr_libc(ret: libc::c_int) -> IoResult<()> {
     if ret != 0 {

branches/try2/src/libnative/io/net.rs

@@ -120,7 +120,7 @@ fn last_error() -> io::IoError {
     extern "system" {
         fn WSAGetLastError() -> libc::c_int;
     }
-    io::IoError::from_errno(unsafe { WSAGetLastError() } as uint, true)
+    super::translate_error(unsafe { WSAGetLastError() }, true)
 }
 
 #[cfg(not(windows))]

branches/try2/src/libnative/io/process.rs

@@ -481,7 +481,7 @@ fn spawn_process_os(config: p::ProcessConfig,
                                     (bytes[1] << 16) as i32 |
                                     (bytes[2] <<  8) as i32 |
                                     (bytes[3] <<  0) as i32;
-                        Err(io::IoError::from_errno(errno as uint, false))
+                        Err(super::translate_error(errno, false))
                     }
                     Err(e) => {
                         assert!(e.kind == io::BrokenPipe ||

branches/try2/src/librand/distributions/exponential.rs

@@ -126,7 +126,7 @@ mod bench {
 
     #[bench]
     fn rand_exp(bh: &mut BenchHarness) {
-        let mut rng = XorShiftRng::new().unwrap();
+        let mut rng = XorShiftRng::new();
         let mut exp = Exp::new(2.71828 * 3.14159);
 
         bh.iter(|| {

branches/try2/src/librand/distributions/gamma.rs

@@ -11,6 +11,7 @@
 //! The Gamma and derived distributions.
 
 use std::num::Float;
+use std::num;
 use {Rng, Open01};
 use super::normal::StandardNormal;
 use super::{IndependentSample, Sample, Exp};
@@ -113,7 +114,7 @@ impl GammaLargeShape {
         GammaLargeShape {
             shape: shape,
             scale: scale,
-            c: 1. / (9. * d).sqrt(),
+            c: 1. / num::sqrt(9. * d),
             d: d
         }
     }
@@ -142,7 +143,7 @@ impl IndependentSample<f64> for GammaSmallShape {
     fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64 {
         let Open01(u) = rng.gen::<Open01<f64>>();
 
-        self.large_shape.ind_sample(rng) * u.powf(&self.inv_shape)
+        self.large_shape.ind_sample(rng) * num::powf(u, self.inv_shape)
     }
 }
 impl IndependentSample<f64> for GammaLargeShape {
@@ -159,7 +160,7 @@ impl IndependentSample<f64> for GammaLargeShape {
 
             let x_sqr = x * x;
             if u < 1.0 - 0.0331 * x_sqr * x_sqr ||
-                u.ln() < 0.5 * x_sqr + self.d * (1.0 - v + v.ln()) {
+                num::ln(u) < 0.5 * x_sqr + self.d * (1.0 - v + num::ln(v)) {
                 return self.d * v * self.scale
             }
         }
@@ -369,14 +370,14 @@ mod bench {
     use self::test::BenchHarness;
     use std::mem::size_of;
     use distributions::IndependentSample;
-    use {XorShiftRng, RAND_BENCH_N};
+    use {StdRng, RAND_BENCH_N};
     use super::Gamma;
 
 
     #[bench]
     fn bench_gamma_large_shape(bh: &mut BenchHarness) {
         let gamma = Gamma::new(10., 1.0);
-        let mut rng = XorShiftRng::new().unwrap();
+        let mut rng = StdRng::new();
 
         bh.iter(|| {
             for _ in range(0, RAND_BENCH_N) {
@@ -389,7 +390,7 @@ mod bench {
     #[bench]
     fn bench_gamma_small_shape(bh: &mut BenchHarness) {
         let gamma = Gamma::new(0.1, 1.0);
-        let mut rng = XorShiftRng::new().unwrap();
+        let mut rng = StdRng::new();
 
         bh.iter(|| {
             for _ in range(0, RAND_BENCH_N) {

branches/try2/src/librand/distributions/normal.rs

@@ -193,7 +193,7 @@ mod bench {
 
     #[bench]
     fn rand_normal(bh: &mut BenchHarness) {
-        let mut rng = XorShiftRng::new().unwrap();
+        let mut rng = XorShiftRng::new();
         let mut normal = Normal::new(-2.71828, 3.14159);
 
         bh.iter(|| {