Merge pull request #726 from dhardy/fmt

Add rustfmt configuration and accept a few of its changes

Author: dhardy

examples/monte-carlo.rs

@@ -11,7 +11,7 @@
 //!
 //! Imagine that we have a square with sides of length 2 and a unit circle
 //! (radius = 1), both centered at the origin. The areas are:
-//! 
+//!
 //! ```text
 //!     area of circle  = πr² = π * r * r = π
 //!     area of square  = 2² = 4
@@ -24,28 +24,28 @@
 //! the square at random, calculate the fraction that fall within the circle,
 //! and multiply this fraction by 4.
 
-#![cfg(feature="std")]
+#![cfg(feature = "std")]
 
 
 extern crate rand;
 
 use rand::distributions::{Distribution, Uniform};
 
 fn main() {
-   let range = Uniform::new(-1.0f64, 1.0);
-   let mut rng = rand::thread_rng();
-
-   let total = 1_000_000;
-   let mut in_circle = 0;
-
-   for _ in 0..total {
-       let a = range.sample(&mut rng);
-       let b = range.sample(&mut rng);
-       if a*a + b*b <= 1.0 {
-           in_circle += 1;
-       }
-   }
-
-   // prints something close to 3.14159...
-   println!("π is approximately {}", 4. * (in_circle as f64) / (total as f64));
+    let range = Uniform::new(-1.0f64, 1.0);
+    let mut rng = rand::thread_rng();
+
+    let total = 1_000_000;
+    let mut in_circle = 0;
+
+    for _ in 0..total {
+        let a = range.sample(&mut rng);
+        let b = range.sample(&mut rng);
+        if a*a + b*b <= 1.0 {
+            in_circle += 1;
+        }
+    }
+
+    // prints something close to 3.14159...
+    println!("π is approximately {}", 4. * (in_circle as f64) / (total as f64));
 }

examples/monty-hall.rs

@@ -26,22 +26,21 @@
 //!
 //! [Monty Hall Problem]: https://en.wikipedia.org/wiki/Monty_Hall_problem
 
-#![cfg(feature="std")]
+#![cfg(feature = "std")]
 
 
 extern crate rand;
 
-use rand::Rng;
 use rand::distributions::{Distribution, Uniform};
+use rand::Rng;
 
 struct SimulationResult {
     win: bool,
     switch: bool,
 }
 
 // Run a single simulation of the Monty Hall problem.
-fn simulate<R: Rng>(random_door: &Uniform<u32>, rng: &mut R)
-                    -> SimulationResult {
+fn simulate<R: Rng>(random_door: &Uniform<u32>, rng: &mut R) -> SimulationResult {
     let car = random_door.sample(rng);
 
     // This is our initial choice

rustfmt.toml

@@ -0,0 +1,32 @@
+# This rustfmt file is added for configuration, but in practice much of our
+# code is hand-formatted, frequently with more readable results.
+
+# Comments:
+normalize_comments = true
+wrap_comments = false
+format_doc_comments = true
+comment_width = 90      # small excess is okay but prefer 80
+
+# Arguments:
+use_small_heuristics = "max"
+fn_args_density = "compressed"
+fn_single_line = false
+overflow_delimited_expr = true
+where_single_line = true
+
+# enum_discrim_align_threshold = 20
+# struct_field_align_threshold = 20
+
+# Compatibility:
+use_try_shorthand = true        # stable since Rustc 1.13.0
+use_field_init_shorthand = true     # stable since Rustc 1.17.0
+edition = "2015"        # we require compatibility back to 1.22.0
+
+# Misc:
+blank_lines_upper_bound = 2
+reorder_impl_items = true
+# report_todo = "Unnumbered"
+# report_fixme = "Unnumbered"
+
+# Ignored files:
+ignore = []

src/lib.rs

@@ -211,7 +211,8 @@ pub trait Rng: RngCore {
     /// println!("{:?}", rng.gen::<(f64, bool)>());
     /// ```
     #[inline]
-    fn gen<T>(&mut self) -> T where Standard: Distribution<T> {
+    fn gen<T>(&mut self) -> T
+    where Standard: Distribution<T> {
         Standard.sample(self)
     }
 
@@ -240,8 +241,10 @@ pub trait Rng: RngCore {
     ///
     /// [`Uniform`]: distributions::uniform::Uniform
     fn gen_range<T: SampleUniform, B1, B2>(&mut self, low: B1, high: B2) -> T
-        where B1: SampleBorrow<T> + Sized,
-              B2: SampleBorrow<T> + Sized {
+    where
+        B1: SampleBorrow<T> + Sized,
+        B2: SampleBorrow<T> + Sized,
+    {
         T::Sampler::sample_single(low, high, self)
     }
 
@@ -290,9 +293,10 @@ pub trait Rng: RngCore {
     ///     println!("Not a 6; rolling again!");
     /// }
     /// ```
-    fn sample_iter<'a, T, D: Distribution<T>>(&'a mut self, distr: &'a D)
-        -> distributions::DistIter<'a, D, Self, T> where Self: Sized
-    {
+    fn sample_iter<'a, T, D: Distribution<T>>(
+        &'a mut self, distr: &'a D,
+    ) -> distributions::DistIter<'a, D, Self, T>
+    where Self: Sized {
         distr.sample_iter(self)
     }
 
@@ -649,7 +653,8 @@ impl<R: SeedableRng> FromEntropy for R {
 /// [`Standard`]: distributions::Standard
 #[cfg(feature="std")]
 #[inline]
-pub fn random<T>() -> T where Standard: Distribution<T> {
+pub fn random<T>() -> T
+where Standard: Distribution<T> {
     thread_rng().gen()
 }
 

src/seq/index.rs

@@ -173,14 +173,13 @@ impl ExactSizeIterator for IndexVecIntoIter {}
 /// Note that performance is significantly better over `u32` indices than over
 /// `u64` indices. Because of this we hide the underlying type behind an
 /// abstraction, `IndexVec`.
-/// 
+///
 /// If an allocation-free `no_std` function is required, it is suggested
 /// to adapt the internal `sample_floyd` implementation.
 ///
 /// Panics if `amount > length`.
 pub fn sample<R>(rng: &mut R, length: usize, amount: usize) -> IndexVec
-    where R: Rng + ?Sized,
-{
+where R: Rng + ?Sized {
     if amount > length {
         panic!("`amount` of samples must be less than or equal to `length`");
     }
@@ -227,8 +226,7 @@ pub fn sample<R>(rng: &mut R, length: usize, amount: usize) -> IndexVec
 ///
 /// This implementation uses `O(amount)` memory and `O(amount^2)` time.
 fn sample_floyd<R>(rng: &mut R, length: u32, amount: u32) -> IndexVec
-    where R: Rng + ?Sized,
-{
+where R: Rng + ?Sized {
     // For small amount we use Floyd's fully-shuffled variant. For larger
     // amounts this is slow due to Vec::insert performance, so we shuffle
     // afterwards. Benchmarks show little overhead from extra logic.
@@ -274,8 +272,7 @@ fn sample_floyd<R>(rng: &mut R, length: u32, amount: u32) -> IndexVec
 ///
 /// Set-up is `O(length)` time and memory and shuffling is `O(amount)` time.
 fn sample_inplace<R>(rng: &mut R, length: u32, amount: u32) -> IndexVec
-    where R: Rng + ?Sized,
-{
+where R: Rng + ?Sized {
     debug_assert!(amount <= length);
     let mut indices: Vec<u32> = Vec::with_capacity(length as usize);
     indices.extend(0..length);
@@ -290,13 +287,12 @@ fn sample_inplace<R>(rng: &mut R, length: u32, amount: u32) -> IndexVec
 
 /// Randomly sample exactly `amount` indices from `0..length`, using rejection
 /// sampling.
-/// 
+///
 /// Since `amount <<< length` there is a low chance of a random sample in
 /// `0..length` being a duplicate. We test for duplicates and resample where
 /// necessary. The algorithm is `O(amount)` time and memory.
 fn sample_rejection<R>(rng: &mut R, length: usize, amount: usize) -> IndexVec
-    where R: Rng + ?Sized,
-{
+where R: Rng + ?Sized {
     debug_assert!(amount < length);
     #[cfg(feature="std")] let mut cache = HashSet::with_capacity(amount);
     #[cfg(not(feature="std"))] let mut cache = BTreeSet::new();