rustfmt: function specifications

dhardy · dhardy · commit 079ff0d54130 · 2020-01-02T15:46:14.000Z
diff --git a/rand_core/src/block.rs b/rand_core/src/block.rs
@@ -133,7 +133,7 @@ impl<R: BlockRngCore> BlockRng<R> {
     /// Create a new `BlockRng` from an existing RNG implementing
     /// `BlockRngCore`. Results will be generated on first use.
     #[inline]
-    pub fn new(core: R) -> BlockRng<R>{
+    pub fn new(core: R) -> BlockRng<R> {
         let results_empty = R::Results::default();
         BlockRng {
             core,
@@ -307,7 +307,7 @@ impl<R: BlockRngCore> BlockRng64<R> {
     /// Create a new `BlockRng` from an existing RNG implementing
     /// `BlockRngCore`. Results will be generated on first use.
     #[inline]
-    pub fn new(core: R) -> BlockRng64<R>{
+    pub fn new(core: R) -> BlockRng64<R> {
         let results_empty = R::Results::default();
         BlockRng64 {
             core,
diff --git a/rand_distr/src/exponential.rs b/rand_distr/src/exponential.rs
@@ -157,9 +157,9 @@ mod test {
 
     #[test]
     fn value_stability() {
-        fn test_samples<N: Float + core::fmt::Debug, D: Distribution<N>>
-        (distr: D, zero: N, expected: &[N])
-        {
+        fn test_samples<N: Float + core::fmt::Debug, D: Distribution<N>>(
+            distr: D, zero: N, expected: &[N],
+        ) {
             let mut rng = crate::test::rng(223);
             let mut buf = [zero; 4];
             for x in &mut buf {
diff --git a/rand_distr/src/gamma.rs b/rand_distr/src/gamma.rs
@@ -568,9 +568,9 @@ mod test {
 
     #[test]
     fn value_stability() {
-        fn test_samples<N: Float + core::fmt::Debug, D: Distribution<N>>
-        (distr: D, zero: N, expected: &[N])
-        {
+        fn test_samples<N: Float + core::fmt::Debug, D: Distribution<N>>(
+            distr: D, zero: N, expected: &[N],
+        ) {
             let mut rng = crate::test::rng(223);
             let mut buf = [zero; 4];
             for x in &mut buf {
diff --git a/rand_distr/src/normal.rs b/rand_distr/src/normal.rs
@@ -232,9 +232,9 @@ mod tests {
 
     #[test]
     fn value_stability() {
-        fn test_samples<N: Float + core::fmt::Debug, D: Distribution<N>>
-        (distr: D, zero: N, expected: &[N])
-        {
+        fn test_samples<N: Float + core::fmt::Debug, D: Distribution<N>>(
+            distr: D, zero: N, expected: &[N],
+        ) {
             let mut rng = crate::test::rng(213);
             let mut buf = [zero; 4];
             for x in &mut buf {
diff --git a/rand_distr/src/pareto.rs b/rand_distr/src/pareto.rs
@@ -103,9 +103,9 @@ mod tests {
 
     #[test]
     fn value_stability() {
-        fn test_samples<N: Float + core::fmt::Debug, D: Distribution<N>>
-        (distr: D, zero: N, expected: &[N])
-        {
+        fn test_samples<N: Float + core::fmt::Debug, D: Distribution<N>>(
+            distr: D, zero: N, expected: &[N],
+        ) {
             let mut rng = crate::test::rng(213);
             let mut buf = [zero; 4];
             for x in &mut buf {
diff --git a/rand_distr/src/poisson.rs b/rand_distr/src/poisson.rs
@@ -243,9 +243,9 @@ mod test {
 
     #[test]
     fn value_stability() {
-        fn test_samples<N: Float + core::fmt::Debug, D: Distribution<N>>
-        (distr: D, zero: N, expected: &[N])
-        {
+        fn test_samples<N: Float + core::fmt::Debug, D: Distribution<N>>(
+            distr: D, zero: N, expected: &[N],
+        ) {
             let mut rng = crate::test::rng(223);
             let mut buf = [zero; 4];
             for x in &mut buf {
diff --git a/rand_distr/src/utils.rs b/rand_distr/src/utils.rs
@@ -64,9 +64,15 @@ pub trait Float:
 
 impl Float for f32 {
     #[inline]
-    fn pi() -> Self { core::f32::consts::PI }
+    fn pi() -> Self {
+        core::f32::consts::PI
+    }
+
     #[inline]
-    fn from(x: f64) -> Self { x as f32 }
+    fn from(x: f64) -> Self {
+        x as f32
+    }
+
     #[inline]
     fn to_u64(self) -> Option<u64> {
         if self >= 0. && self <= ::core::u64::MAX as f32 {
@@ -77,21 +83,40 @@ impl Float for f32 {
     }
 
     #[inline]
-    fn abs(self) -> Self { self.abs() }
+    fn abs(self) -> Self {
+        self.abs()
+    }
+
     #[inline]
-    fn floor(self) -> Self { self.floor() }
-    
+    fn floor(self) -> Self {
+        self.floor()
+    }
+
     #[inline]
-    fn exp(self) -> Self { self.exp() }
+    fn exp(self) -> Self {
+        self.exp()
+    }
+
     #[inline]
-    fn ln(self) -> Self { self.ln() }
+    fn ln(self) -> Self {
+        self.ln()
+    }
+
     #[inline]
-    fn sqrt(self) -> Self { self.sqrt() }
+    fn sqrt(self) -> Self {
+        self.sqrt()
+    }
+
     #[inline]
-    fn powf(self, power: Self) -> Self { self.powf(power) }
-    
+    fn powf(self, power: Self) -> Self {
+        self.powf(power)
+    }
+
     #[inline]
-    fn tan(self) -> Self { self.tan() }
+    fn tan(self) -> Self {
+        self.tan()
+    }
+
     #[inline]
     fn log_gamma(self) -> Self {
         let result = log_gamma(self.into());
@@ -103,9 +128,15 @@ impl Float for f32 {
 
 impl Float for f64 {
     #[inline]
-    fn pi() -> Self { core::f64::consts::PI }
+    fn pi() -> Self {
+        core::f64::consts::PI
+    }
+
     #[inline]
-    fn from(x: f64) -> Self { x }
+    fn from(x: f64) -> Self {
+        x
+    }
+
     #[inline]
     fn to_u64(self) -> Option<u64> {
         if self >= 0. && self <= ::core::u64::MAX as f64 {
@@ -116,23 +147,44 @@ impl Float for f64 {
     }
 
     #[inline]
-    fn abs(self) -> Self { self.abs() }
+    fn abs(self) -> Self {
+        self.abs()
+    }
+
     #[inline]
-    fn floor(self) -> Self { self.floor() }
-    
+    fn floor(self) -> Self {
+        self.floor()
+    }
+
     #[inline]
-    fn exp(self) -> Self { self.exp() }
+    fn exp(self) -> Self {
+        self.exp()
+    }
+
     #[inline]
-    fn ln(self) -> Self { self.ln() }
+    fn ln(self) -> Self {
+        self.ln()
+    }
+
     #[inline]
-    fn sqrt(self) -> Self { self.sqrt() }
+    fn sqrt(self) -> Self {
+        self.sqrt()
+    }
+
     #[inline]
-    fn powf(self, power: Self) -> Self { self.powf(power) }
-    
+    fn powf(self, power: Self) -> Self {
+        self.powf(power)
+    }
+
     #[inline]
-    fn tan(self) -> Self { self.tan() }
+    fn tan(self) -> Self {
+        self.tan()
+    }
+
     #[inline]
-    fn log_gamma(self) -> Self { log_gamma(self) }
+    fn log_gamma(self) -> Self {
+        log_gamma(self)
+    }
 }
 
 /// Calculates ln(gamma(x)) (natural logarithm of the gamma
diff --git a/rand_distr/src/weibull.rs b/rand_distr/src/weibull.rs
@@ -100,9 +100,9 @@ mod tests {
 
     #[test]
     fn value_stability() {
-        fn test_samples<N: Float + core::fmt::Debug, D: Distribution<N>>
-        (distr: D, zero: N, expected: &[N])
-        {
+        fn test_samples<N: Float + core::fmt::Debug, D: Distribution<N>>(
+            distr: D, zero: N, expected: &[N],
+        ) {
             let mut rng = crate::test::rng(213);
             let mut buf = [zero; 4];
             for x in &mut buf {
diff --git a/rand_hc/src/hc128.rs b/rand_hc/src/hc128.rs
@@ -173,9 +173,7 @@ impl BlockRngCore for Hc128Core {
 impl Hc128Core {
     // One step of HC-128, update P and generate 32 bits keystream
     #[inline(always)]
-    fn step_p(&mut self, i: usize, i511: usize, i3: usize, i10: usize, i12: usize)
-         -> u32
-    {
+    fn step_p(&mut self, i: usize, i511: usize, i3: usize, i10: usize, i12: usize) -> u32 {
         let (p, q) = self.t.split_at_mut(512);
         // FIXME: it would be great if we the bounds checks here could be
         // optimized out, and we would not need unsafe.
@@ -202,9 +200,7 @@ impl Hc128Core {
     // Similar to `step_p`, but `p` and `q` are swapped, and the rotates are to
     // the left instead of to the right.
     #[inline(always)]
-    fn step_q(&mut self, i: usize, i511: usize, i3: usize, i10: usize, i12: usize)
-         -> u32
-    {
+    fn step_q(&mut self, i: usize, i511: usize, i3: usize, i10: usize, i12: usize) -> u32 {
         let (p, q) = self.t.split_at_mut(512);
         unsafe {
             let temp0 = q.get_unchecked(i511).rotate_left(23);
diff --git a/src/distributions/mod.rs b/src/distributions/mod.rs
@@ -386,7 +386,9 @@ mod tests {
 
     #[test]
     fn test_make_an_iter() {
-        fn ten_dice_rolls_other_than_five<'a, R: Rng>(rng: &'a mut R) -> impl Iterator<Item = i32> + 'a {
+        fn ten_dice_rolls_other_than_five<'a, R: Rng>(
+            rng: &'a mut R,
+        ) -> impl Iterator<Item = i32> + 'a {
             Uniform::new_inclusive(1, 6)
                 .sample_iter(rng)
                 .filter(|x| *x != 5)
diff --git a/src/distributions/other.rs b/src/distributions/other.rs
@@ -118,7 +118,9 @@ macro_rules! tuple_impl {
 impl Distribution<()> for Standard {
     #[allow(clippy::unused_unit)]
     #[inline]
-    fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> () { () }
+    fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> () {
+        ()
+    }
 }
 tuple_impl! {A}
 tuple_impl! {A, B}
@@ -227,7 +229,8 @@ mod tests {
     #[test]
     fn value_stability() {
         fn test_samples<T: Copy + core::fmt::Debug + PartialEq, D: Distribution<T>>(
-            distr: &D, zero: T, expected: &[T]) {
+            distr: &D, zero: T, expected: &[T],
+        ) {
             let mut rng = crate::test::rng(807);
             let mut buf = [zero; 5];
             for x in &mut buf {
diff --git a/src/distributions/uniform.rs b/src/distributions/uniform.rs
@@ -294,13 +294,17 @@ impl<Borrowed> SampleBorrow<Borrowed> for Borrowed
 where Borrowed: SampleUniform
 {
     #[inline(always)]
-    fn borrow(&self) -> &Borrowed { self }
+    fn borrow(&self) -> &Borrowed {
+        self
+    }
 }
 impl<'a, Borrowed> SampleBorrow<Borrowed> for &'a Borrowed
 where Borrowed: SampleUniform
 {
     #[inline(always)]
-   fn borrow(&self) -> &Borrowed { *self }
+    fn borrow(&self) -> &Borrowed {
+        *self
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/src/distributions/utils.rs b/src/distributions/utils.rs
diff --git a/src/rngs/adapter/reseeding.rs b/src/rngs/adapter/reseeding.rs
diff --git a/src/seq/index.rs b/src/seq/index.rs
diff --git a/src/seq/mod.rs b/src/seq/mod.rs
