Rustfmt

Author: Amanieu

src/external_trait_impls/rayon/helpers.rs

@@ -3,19 +3,20 @@ use alloc::vec::Vec;
 
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 
-
 /// Helper for collecting parallel iterators to an intermediary
 pub(super) fn collect<I: IntoParallelIterator>(iter: I) -> (LinkedList<Vec<I::Item>>, usize) {
     let list = iter
         .into_par_iter()
         .fold(Vec::new, |mut vec, elem| {
             vec.push(elem);
             vec
-        }).map(|vec| {
+        })
+        .map(|vec| {
             let mut list = LinkedList::new();
             list.push_back(vec);
             list
-        }).reduce(LinkedList::new, |mut list1, mut list2| {
+        })
+        .reduce(LinkedList::new, |mut list1, mut list2| {
             list1.append(&mut list2);
             list1
         });

src/external_trait_impls/rayon/map.rs

@@ -11,7 +11,6 @@ use super::raw;
 pub use super::raw::{IntoParIter, ParIter, ParIterMut};
 pub use super::raw::{ParKeys, ParValues, ParValuesMut};
 
-
 impl<K: Sync, V, S> HashMap<K, V, S> {
     /// Visits (potentially in parallel) immutably borrowed keys in an arbitrary order.
     #[inline]
@@ -47,13 +46,13 @@ where
     ///
     /// This method runs in a potentially parallel fashion.
     pub fn par_eq(&self, other: &Self) -> bool {
-        self.len() == other.len() && self
-            .into_par_iter()
-            .all(|(key, value)| other.get(key).map_or(false, |v| *value == *v))
+        self.len() == other.len()
+            && self
+                .into_par_iter()
+                .all(|(key, value)| other.get(key).map_or(false, |v| *value == *v))
     }
 }
 
-
 impl<K: Send, V: Send, S> IntoParallelIterator for HashMap<K, V, S> {
     type Item = (K, V);
     type Iter = raw::IntoParIter<K, V>;
@@ -81,7 +80,6 @@ impl<'a, K: Sync, V: Send, S> IntoParallelIterator for &'a mut HashMap<K, V, S>
     }
 }
 
-
 /// Collect (key, value) pairs from a parallel iterator into a
 /// hashmap. If multiple pairs correspond to the same key, then the
 /// ones produced earlier in the parallel iterator will be
@@ -153,7 +151,6 @@ where
     }
 }
 
-
 #[cfg(test)]
 mod test_par_map {
     use alloc::vec::Vec;

src/external_trait_impls/rayon/raw.rs

@@ -12,7 +12,6 @@ use rayon::iter::{
 
 use raw::{RawIterRange, RawTable};
 
-
 #[inline]
 unsafe fn raw_iter_range_split_and_convert<T, P>(iter_range: RawIterRange<T>) -> (P, Option<P>)
 where
@@ -22,7 +21,6 @@ where
     (P::from(left), right.map(P::from))
 }
 
-
 /// Parallel iterator over shared references to entries in a map.
 ///
 /// This iterator is created by the [`par_iter`] method on [`HashMap`]
@@ -52,7 +50,8 @@ impl<'a, K: Sync, V: Sync> ParallelIterator for ParIter<'a, K, V> {
     type Item = (&'a K, &'a V);
 
     fn drive_unindexed<C>(self, consumer: C) -> C::Result
-        where C: UnindexedConsumer<Self::Item>
+    where
+        C: UnindexedConsumer<Self::Item>,
     {
         let buckets = unsafe { self.table.iter().iter };
         let producer = ParIterProducer::from(buckets);
@@ -62,7 +61,9 @@ impl<'a, K: Sync, V: Sync> ParallelIterator for ParIter<'a, K, V> {
 
 impl<'a, K, V> Clone for ParIter<'a, K, V> {
     fn clone(&self) -> Self {
-        ParIter { table: &*self.table }
+        ParIter {
+            table: &*self.table,
+        }
     }
 }
 
@@ -86,7 +87,10 @@ struct ParIterProducer<'a, K: 'a, V: 'a> {
 impl<'a, K, V> From<RawIterRange<(K, V)>> for ParIterProducer<'a, K, V> {
     #[inline]
     fn from(iter: RawIterRange<(K, V)>) -> Self {
-        Self { iter, marker: PhantomData }
+        Self {
+            iter,
+            marker: PhantomData,
+        }
     }
 }
 
@@ -100,7 +104,8 @@ impl<'a, K: Sync, V: Sync> UnindexedProducer for ParIterProducer<'a, K, V> {
     }
 
     fn fold_with<F>(self, folder: F) -> F
-        where F: Folder<Self::Item>
+    where
+        F: Folder<Self::Item>,
     {
         let iter = self.iter.map(|bucket| unsafe {
             let (ref k, ref v) = *bucket.as_ref();
@@ -110,7 +115,6 @@ impl<'a, K: Sync, V: Sync> UnindexedProducer for ParIterProducer<'a, K, V> {
     }
 }
 
-
 /// Parallel iterator over shared references to keys in a map.
 ///
 /// This iterator is created by the [`par_keys`] method on [`HashMap`].
@@ -146,16 +150,16 @@ impl<'a, K: Sync, V> ParallelIterator for ParKeys<'a, K, V> {
 
 impl<'a, K, V> Clone for ParKeys<'a, K, V> {
     fn clone(&self) -> Self {
-        ParKeys { table: &*self.table }
+        ParKeys {
+            table: &*self.table,
+        }
     }
 }
 
 impl<'a, K: fmt::Debug, V> fmt::Debug for ParKeys<'a, K, V> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let iter = unsafe { self.table.iter() };
-        let entries = iter.map(|bucket| unsafe {
-            &bucket.as_ref().0
-        });
+        let entries = iter.map(|bucket| unsafe { &bucket.as_ref().0 });
 
         f.debug_list().entries(entries).finish()
     }
@@ -169,7 +173,10 @@ struct ParKeysProducer<'a, K: 'a, V: 'a> {
 impl<'a, K, V> From<RawIterRange<(K, V)>> for ParKeysProducer<'a, K, V> {
     #[inline]
     fn from(iter: RawIterRange<(K, V)>) -> Self {
-        Self { iter, marker: PhantomData }
+        Self {
+            iter,
+            marker: PhantomData,
+        }
     }
 }
 
@@ -186,14 +193,11 @@ impl<'a, K: Sync, V> UnindexedProducer for ParKeysProducer<'a, K, V> {
     where
         F: Folder<Self::Item>,
     {
-        let iter = self.iter.map(|bucket| unsafe {
-            &bucket.as_ref().0
-        });
+        let iter = self.iter.map(|bucket| unsafe { &bucket.as_ref().0 });
         folder.consume_iter(iter)
     }
 }
 
-
 /// Parallel iterator over shared references to values in a map.
 ///
 /// This iterator is created by the [`par_values`] method on [`HashMap`].
@@ -229,16 +233,16 @@ impl<'a, K, V: Sync> ParallelIterator for ParValues<'a, K, V> {
 
 impl<'a, K, V> Clone for ParValues<'a, K, V> {
     fn clone(&self) -> Self {
-        ParValues { table: &*self.table }
+        ParValues {
+            table: &*self.table,
+        }
     }
 }
 
 impl<'a, K, V: fmt::Debug> fmt::Debug for ParValues<'a, K, V> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let iter = unsafe { self.table.iter() };
-        let entries = iter.map(|bucket| unsafe {
-            &bucket.as_ref().1
-        });
+        let entries = iter.map(|bucket| unsafe { &bucket.as_ref().1 });
 
         f.debug_list().entries(entries).finish()
     }
@@ -252,7 +256,10 @@ struct ParValuesProducer<'a, K: 'a, V: 'a> {
 impl<'a, K, V> From<RawIterRange<(K, V)>> for ParValuesProducer<'a, K, V> {
     #[inline]
     fn from(iter: RawIterRange<(K, V)>) -> Self {
-        Self { iter, marker: PhantomData }
+        Self {
+            iter,
+            marker: PhantomData,
+        }
     }
 }
 
@@ -269,14 +276,11 @@ impl<'a, K, V: Sync> UnindexedProducer for ParValuesProducer<'a, K, V> {
     where
         F: Folder<Self::Item>,
     {
-        let iter = self.iter.map(|bucket| unsafe {
-            &bucket.as_ref().1
-        });
+        let iter = self.iter.map(|bucket| unsafe { &bucket.as_ref().1 });
         folder.consume_iter(iter)
     }
 }
 
-
 /// Parallel iterator over mutable references to entries in a map.
 ///
 /// This iterator is created by the [`par_iter_mut`] method on [`HashMap`]
@@ -336,7 +340,10 @@ struct ParIterMutProducer<'a, K: 'a, V: 'a> {
 impl<'a, K, V> From<RawIterRange<(K, V)>> for ParIterMutProducer<'a, K, V> {
     #[inline]
     fn from(iter: RawIterRange<(K, V)>) -> Self {
-        Self { iter, marker: PhantomData }
+        Self {
+            iter,
+            marker: PhantomData,
+        }
     }
 }
 
@@ -361,7 +368,6 @@ impl<'a, K: Sync, V: Send> UnindexedProducer for ParIterMutProducer<'a, K, V> {
     }
 }
 
-
 /// Parallel iterator over mutable references to values in a map.
 ///
 /// This iterator is created by the [`par_values_mut`] method on [`HashMap`].
@@ -398,9 +404,7 @@ impl<'a, K, V: Send> ParallelIterator for ParValuesMut<'a, K, V> {
 impl<'a, K, V: fmt::Debug> fmt::Debug for ParValuesMut<'a, K, V> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let iter = unsafe { self.table.iter() };
-        let entries = iter.map(|bucket| unsafe {
-            &bucket.as_ref().1
-        });
+        let entries = iter.map(|bucket| unsafe { &bucket.as_ref().1 });
 
         f.debug_list().entries(entries).finish()
     }
@@ -415,7 +419,10 @@ struct ParValuesMutProducer<'a, K: 'a, V: 'a> {
 impl<'a, K, V> From<RawIterRange<(K, V)>> for ParValuesMutProducer<'a, K, V> {
     #[inline]
     fn from(iter: RawIterRange<(K, V)>) -> Self {
-        Self { iter, marker: PhantomData }
+        Self {
+            iter,
+            marker: PhantomData,
+        }
     }
 }
 
@@ -432,14 +439,11 @@ impl<'a, K, V: Send> UnindexedProducer for ParValuesMutProducer<'a, K, V> {
     where
         F: Folder<Self::Item>,
     {
-        let iter = self.iter.map(|bucket| unsafe {
-            &mut bucket.as_mut().1
-        });
+        let iter = self.iter.map(|bucket| unsafe { &mut bucket.as_mut().1 });
         folder.consume_iter(iter)
     }
 }
 
-
 /// Parallel iterator over entries of a consumed map.
 ///
 /// This iterator is created by the [`into_par_iter`] method on [`HashMap`]
@@ -512,9 +516,7 @@ impl<K: Send, V: Send> UnindexedProducer for IntoParIterProducer<K, V> {
     where
         F: Folder<Self::Item>,
     {
-        let iter = self.iter.by_ref().map(|bucket| unsafe {
-            bucket.read()
-        });
+        let iter = self.iter.by_ref().map(|bucket| unsafe { bucket.read() });
         folder.consume_iter(iter)
     }
 }

src/external_trait_impls/rayon/set.rs

@@ -3,15 +3,14 @@
 use core::hash::{BuildHasher, Hash};
 
 use rayon::iter::{
-    plumbing::UnindexedConsumer,
-    FromParallelIterator, IntoParallelIterator, ParallelExtend, ParallelIterator,
+    plumbing::UnindexedConsumer, FromParallelIterator, IntoParallelIterator, ParallelExtend,
+    ParallelIterator,
 };
 
 use hash_set::HashSet;
 
 use super::map;
 
-
 /// Parallel iterator over elements of a consumed set.
 ///
 /// This iterator is created by the [`into_par_iter`] method on [`HashSet`]
@@ -349,7 +348,6 @@ where
     }
 }
 
-
 #[cfg(test)]
 mod test_par_set {
     use alloc::vec::Vec;
@@ -450,7 +448,8 @@ mod test_par_set {
             .map(|x| {
                 assert!(expected.contains(x));
                 1
-            }).sum::<usize>();
+            })
+            .sum::<usize>();
         assert_eq!(i, expected.len());
     }
 
@@ -474,7 +473,8 @@ mod test_par_set {
             .map(|x| {
                 assert!(expected.contains(x));
                 1
-            }).sum::<usize>();
+            })
+            .sum::<usize>();
         assert_eq!(i, expected.len());
     }
 
@@ -501,7 +501,8 @@ mod test_par_set {
             .map(|x| {
                 assert!(expected.contains(x));
                 1
-            }).sum::<usize>();
+            })
+            .sum::<usize>();
         assert_eq!(i, expected.len());
     }
 
@@ -532,7 +533,8 @@ mod test_par_set {
             .map(|x| {
                 assert!(expected.contains(x));
                 1
-            }).sum::<usize>();
+            })
+            .sum::<usize>();
         assert_eq!(i, expected.len());
     }
 

src/external_trait_impls/serde.rs

@@ -80,7 +80,9 @@ mod map {
                 }
             }
 
-            let visitor = MapVisitor { marker: PhantomData };
+            let visitor = MapVisitor {
+                marker: PhantomData,
+            };
             deserializer.deserialize_map(visitor)
         }
     }
@@ -153,7 +155,9 @@ mod set {
                 }
             }
 
-            let visitor = SeqVisitor { marker: PhantomData };
+            let visitor = SeqVisitor {
+                marker: PhantomData,
+            };
             deserializer.deserialize_seq(visitor)
         }