Small updates

Author: nrc

src/librand/distributions/mod.rs

@@ -24,7 +24,7 @@ use core::num::{Float, Int};
 
 use {Rng, Rand};
 
-pub use self::range::Range as RandRange;
+pub use self::range::Range;
 pub use self::gamma::{Gamma, ChiSquared, FisherF, StudentT};
 pub use self::normal::{Normal, LogNormal};
 pub use self::exponential::Exp;
@@ -104,7 +104,7 @@ pub struct Weighted<T> {
 /// ```
 pub struct WeightedChoice<'a, T:'a> {
     items: &'a mut [Weighted<T>],
-    weight_range: RandRange<uint>
+    weight_range: Range<uint>
 }
 
 impl<'a, T: Clone> WeightedChoice<'a, T> {
@@ -138,7 +138,7 @@ impl<'a, T: Clone> WeightedChoice<'a, T> {
             items: items,
             // we're likely to be generating numbers in this range
             // relatively often, so might as well cache it
-            weight_range: RandRange::new(0, running_total)
+            weight_range: Range::new(0, running_total)
         }
     }
 }

src/librand/distributions/range.rs

@@ -35,10 +35,10 @@ use distributions::{Sample, IndependentSample};
 /// # Example
 ///
 /// ```rust
-/// use std::rand::distributions::{IndependentSample, RandRange};
+/// use std::rand::distributions::{IndependentSample, Range};
 ///
 /// fn main() {
-///     let between = RandRange::new(10u, 10000u);
+///     let between = Range::new(10u, 10000u);
 ///     let mut rng = std::rand::thread_rng();
 ///     let mut sum = 0;
 ///     for _ in range(0u, 1000) {
@@ -166,17 +166,17 @@ mod tests {
     use std::num::Int;
     use std::prelude::v1::*;
     use distributions::{Sample, IndependentSample};
-    use super::Range as RandRange;
+    use super::Range as Range;
 
     #[should_fail]
     #[test]
     fn test_range_bad_limits_equal() {
-        RandRange::new(10i, 10i);
+        Range::new(10i, 10i);
     }
     #[should_fail]
     #[test]
     fn test_range_bad_limits_flipped() {
-        RandRange::new(10i, 5i);
+        Range::new(10i, 5i);
     }
 
     #[test]
@@ -189,7 +189,7 @@ mod tests {
                                             (10, 127),
                                             (Int::min_value(), Int::max_value())];
                    for &(low, high) in v.iter() {
-                        let mut sampler: RandRange<$ty> = RandRange::new(low, high);
+                        let mut sampler: Range<$ty> = Range::new(low, high);
                         for _ in range(0u, 1000) {
                             let v = sampler.sample(&mut rng);
                             assert!(low <= v && v < high);
@@ -215,7 +215,7 @@ mod tests {
                                             (1e-35, 1e-25),
                                             (-1e35, 1e35)];
                    for &(low, high) in v.iter() {
-                        let mut sampler: RandRange<$ty> = RandRange::new(low, high);
+                        let mut sampler: Range<$ty> = Range::new(low, high);
                         for _ in range(0u, 1000) {
                             let v = sampler.sample(&mut rng);
                             assert!(low <= v && v < high);

src/librand/lib.rs

@@ -40,7 +40,7 @@ use core::prelude::*;
 pub use isaac::{IsaacRng, Isaac64Rng};
 pub use chacha::ChaChaRng;
 
-use distributions::{RandRange, IndependentSample};
+use distributions::{Range, IndependentSample};
 use distributions::range::SampleRange;
 
 #[cfg(test)]
@@ -229,7 +229,7 @@ pub trait Rng : Sized {
     /// ```
     fn gen_range<T: PartialOrd + SampleRange>(&mut self, low: T, high: T) -> T {
         assert!(low < high, "Rng.gen_range called with low >= high");
-        RandRange::new(low, high).ind_sample(self)
+        Range::new(low, high).ind_sample(self)
     }
 
     /// Return a bool with a 1 in n chance of true

src/libstd/rand/mod.rs

@@ -93,10 +93,10 @@
 //!
 //! ```
 //! use std::rand;
-//! use std::rand::distributions::{IndependentSample, RandRange};
+//! use std::rand::distributions::{IndependentSample, Range};
 //!
 //! fn main() {
-//!    let between = RandRange::new(-1f64, 1.);
+//!    let between = Range::new(-1f64, 1.);
 //!    let mut rng = rand::thread_rng();
 //!
 //!    let total = 1_000_000u;
@@ -136,15 +136,15 @@
 //! ```
 //! use std::rand;
 //! use std::rand::Rng;
-//! use std::rand::distributions::{IndependentSample, RandRange};
+//! use std::rand::distributions::{IndependentSample, Range};
 //!
 //! struct SimulationResult {
 //!     win: bool,
 //!     switch: bool,
 //! }
 //!
 //! // Run a single simulation of the Monty Hall problem.
-//! fn simulate<R: Rng>(random_door: &RandRange<uint>, rng: &mut R) -> SimulationResult {
+//! fn simulate<R: Rng>(random_door: &Range<uint>, rng: &mut R) -> SimulationResult {
 //!     let car = random_door.ind_sample(rng);
 //!
 //!     // This is our initial choice
@@ -184,7 +184,7 @@
 //!     let num_simulations = 10000u;
 //!
 //!     let mut rng = rand::thread_rng();
-//!     let random_door = RandRange::new(0u, 3);
+//!     let random_door = Range::new(0u, 3);
 //!
 //!     let (mut switch_wins, mut switch_losses) = (0u, 0u);
 //!     let (mut keep_wins, mut keep_losses) = (0u, 0u);

src/libsyntax/parse/parser.rs

@@ -2560,6 +2560,8 @@ impl<'a> Parser<'a> {
 
                 if found_dotdot || self.eat(&token::CloseDelim(token::Bracket)) {
                     // No expression, expand to a FullRange
+                    // FIXME(#20516) It would be better to use a lang item or
+                    // something for FullRange.
                     hi = self.last_span.hi;
                     let range = ExprStruct(ident_to_path(mk_sp(lo, hi),
                                                          token::special_idents::FullRange),

src/libsyntax/print/pprust.rs

@@ -1553,35 +1553,34 @@ impl<'a> State<'a> {
 
             ast::ExprStruct(ref path, ref fields, ref wth) => {
                 try!(self.print_path(path, true));
-                if fields.is_empty() && wth.is_none() {
-                    return;
-                }
-                try!(word(&mut self.s, "{"));
-                try!(self.commasep_cmnt(
-                    Consistent,
-                    fields.index(&FullRange),
-                    |s, field| {
-                        try!(s.ibox(indent_unit));
-                        try!(s.print_ident(field.ident.node));
-                        try!(s.word_space(":"));
-                        try!(s.print_expr(&*field.expr));
-                        s.end()
-                    },
-                    |f| f.span));
-                match *wth {
-                    Some(ref expr) => {
-                        try!(self.ibox(indent_unit));
-                        if !fields.is_empty() {
-                            try!(word(&mut self.s, ","));
-                            try!(space(&mut self.s));
+                if !(fields.is_empty() && wth.is_none()) {
+                    try!(word(&mut self.s, "{"));
+                    try!(self.commasep_cmnt(
+                        Consistent,
+                        fields.index(&FullRange),
+                        |s, field| {
+                            try!(s.ibox(indent_unit));
+                            try!(s.print_ident(field.ident.node));
+                            try!(s.word_space(":"));
+                            try!(s.print_expr(&*field.expr));
+                            s.end()
+                        },
+                        |f| f.span));
+                    match *wth {
+                        Some(ref expr) => {
+                            try!(self.ibox(indent_unit));
+                            if !fields.is_empty() {
+                                try!(word(&mut self.s, ","));
+                                try!(space(&mut self.s));
+                            }
+                            try!(word(&mut self.s, ".."));
+                            try!(self.print_expr(&**expr));
+                            try!(self.end());
                         }
-                        try!(word(&mut self.s, ".."));
-                        try!(self.print_expr(&**expr));
-                        try!(self.end());
+                        _ => try!(word(&mut self.s, ",")),
                     }
-                    _ => try!(word(&mut self.s, ",")),
+                    try!(word(&mut self.s, "}"));
                 }
-                try!(word(&mut self.s, "}"));
             }
             ast::ExprTup(ref exprs) => {
                 try!(self.popen());