Merge pull request #114 from Razican/cargo_fmt

cargo fmt

Author: cuviper

benches/bench.rs

@@ -1,17 +1,17 @@
 #![feature(test)]
-extern crate test;
-extern crate rand;
 extern crate fnv;
+extern crate rand;
+extern crate test;
 #[macro_use]
 extern crate lazy_static;
 
-use std::hash::Hash;
 use fnv::FnvHasher;
 use std::hash::BuildHasherDefault;
+use std::hash::Hash;
 type FnvBuilder = BuildHasherDefault<FnvHasher>;
 
-use test::Bencher;
 use test::black_box;
+use test::Bencher;
 
 extern crate indexmap;
 
@@ -21,35 +21,27 @@ use std::collections::HashMap;
 use std::iter::FromIterator;
 
 use rand::rngs::SmallRng;
-use rand::FromEntropy;
 use rand::seq::SliceRandom;
+use rand::FromEntropy;
 
 #[bench]
 fn new_hashmap(b: &mut Bencher) {
-    b.iter(|| {
-        HashMap::<String, String>::new()
-    });
+    b.iter(|| HashMap::<String, String>::new());
 }
 
 #[bench]
 fn new_orderedmap(b: &mut Bencher) {
-    b.iter(|| {
-        IndexMap::<String, String>::new()
-    });
+    b.iter(|| IndexMap::<String, String>::new());
 }
 
 #[bench]
 fn with_capacity_10e5_hashmap(b: &mut Bencher) {
-    b.iter(|| {
-        HashMap::<String, String>::with_capacity(10_000)
-    });
+    b.iter(|| HashMap::<String, String>::with_capacity(10_000));
 }
 
 #[bench]
 fn with_capacity_10e5_orderedmap(b: &mut Bencher) {
-    b.iter(|| {
-        IndexMap::<String, String>::with_capacity(10_000)
-    });
+    b.iter(|| IndexMap::<String, String>::with_capacity(10_000));
 }
 
 #[bench]
@@ -228,35 +220,31 @@ fn entry_orderedmap_150(b: &mut Bencher) {
 fn iter_sum_hashmap_10_000(b: &mut Bencher) {
     let c = 10_000;
     let mut map = HashMap::with_capacity(c);
-    let len = c - c/10;
+    let len = c - c / 10;
     for x in 0..len {
         map.insert(x, ());
     }
     assert_eq!(map.len(), len);
-    b.iter(|| {
-        map.keys().sum::<usize>()
-    });
+    b.iter(|| map.keys().sum::<usize>());
 }
 
 #[bench]
 fn iter_sum_orderedmap_10_000(b: &mut Bencher) {
     let c = 10_000;
     let mut map = IndexMap::with_capacity(c);
-    let len = c - c/10;
+    let len = c - c / 10;
     for x in 0..len {
         map.insert(x, ());
     }
     assert_eq!(map.len(), len);
-    b.iter(|| {
-        map.keys().sum::<usize>()
-    });
+    b.iter(|| map.keys().sum::<usize>());
 }
 
 #[bench]
 fn iter_black_box_hashmap_10_000(b: &mut Bencher) {
     let c = 10_000;
     let mut map = HashMap::with_capacity(c);
-    let len = c - c/10;
+    let len = c - c / 10;
     for x in 0..len {
         map.insert(x, ());
     }
@@ -272,7 +260,7 @@ fn iter_black_box_hashmap_10_000(b: &mut Bencher) {
 fn iter_black_box_orderedmap_10_000(b: &mut Bencher) {
     let c = 10_000;
     let mut map = IndexMap::with_capacity(c);
-    let len = c - c/10;
+    let len = c - c / 10;
     for x in 0..len {
         map.insert(x, ());
     }
@@ -285,7 +273,8 @@ fn iter_black_box_orderedmap_10_000(b: &mut Bencher) {
 }
 
 fn shuffled_keys<I>(iter: I) -> Vec<I::Item>
-    where I: IntoIterator
+where
+    I: IntoIterator,
 {
     let mut v = Vec::from_iter(iter);
     let mut rng = SmallRng::from_entropy();
@@ -366,12 +355,9 @@ const LOOKUP_MAP_SIZE: u32 = 100_000_u32;
 const LOOKUP_SAMPLE_SIZE: u32 = 5000;
 const SORT_MAP_SIZE: usize = 10_000;
 
-
 // use lazy_static so that comparison benchmarks use the exact same inputs
 lazy_static! {
-    static ref KEYS: Vec<u32> = {
-        shuffled_keys(0..LOOKUP_MAP_SIZE)
-    };
+    static ref KEYS: Vec<u32> = { shuffled_keys(0..LOOKUP_MAP_SIZE) };
 }
 
 lazy_static! {
@@ -429,7 +415,6 @@ fn lookup_hashmap_100_000_multi(b: &mut Bencher) {
     });
 }
 
-
 #[bench]
 fn lookup_ordermap_100_000_multi(b: &mut Bencher) {
     let map = &*OMAP_100K;
@@ -456,7 +441,6 @@ fn lookup_hashmap_100_000_inorder_multi(b: &mut Bencher) {
     });
 }
 
-
 #[bench]
 fn lookup_ordermap_100_000_inorder_multi(b: &mut Bencher) {
     let map = &*OMAP_100K;
@@ -480,7 +464,6 @@ fn lookup_hashmap_100_000_single(b: &mut Bencher) {
     });
 }
 
-
 #[bench]
 fn lookup_ordermap_100_000_single(b: &mut Bencher) {
     let map = &*OMAP_100K;
@@ -517,7 +500,6 @@ fn grow_fnv_ordermap_100_000(b: &mut Bencher) {
     });
 }
 
-
 const MERGE: u64 = 10_000;
 #[bench]
 fn hashmap_merge_simple(b: &mut Bencher) {
@@ -708,15 +690,13 @@ fn many_retain_hashmap_100_000(b: &mut Bencher) {
     });
 }
 
-
 // simple sort impl for comparison
 pub fn simple_sort<K: Ord + Hash, V>(m: &mut IndexMap<K, V>) {
     let mut ordered: Vec<_> = m.drain(..).collect();
     ordered.sort_by(|left, right| left.0.cmp(&right.0));
     m.extend(ordered);
 }
 
-
 #[bench]
 fn ordermap_sort_s(b: &mut Bencher) {
     let map = OMAP_SORT_S.clone();
@@ -770,17 +750,12 @@ fn ordermap_simple_sort_u32(b: &mut Bencher) {
 fn ordermap_clone_for_sort_s(b: &mut Bencher) {
     let map = OMAP_SORT_S.clone();
 
-    b.iter(|| {
-        map.clone()
-    });
+    b.iter(|| map.clone());
 }
 
 #[bench]
 fn ordermap_clone_for_sort_u32(b: &mut Bencher) {
     let map = OMAP_SORT_U32.clone();
 
-    b.iter(|| {
-        map.clone()
-    });
+    b.iter(|| map.clone());
 }
-

benches/faststring.rs

@@ -1,7 +1,7 @@
 #![feature(test)]
-extern crate test;
-extern crate rand;
 extern crate lazy_static;
+extern crate rand;
+extern crate test;
 
 use test::Bencher;
 
@@ -12,8 +12,8 @@ use indexmap::IndexMap;
 use std::collections::HashMap;
 use std::iter::FromIterator;
 
-use rand::thread_rng;
 use rand::seq::SliceRandom;
+use rand::thread_rng;
 
 use std::hash::{Hash, Hasher};
 
@@ -24,57 +24,51 @@ use std::ops::Deref;
 #[repr(transparent)]
 pub struct OneShot<T: ?Sized>(pub T);
 
-impl Hash for OneShot<str>
-{
+impl Hash for OneShot<str> {
     fn hash<H: Hasher>(&self, h: &mut H) {
         h.write(self.0.as_bytes())
     }
 }
 
 impl<'a, S> From<&'a S> for &'a OneShot<str>
-    where S: AsRef<str>
+where
+    S: AsRef<str>,
 {
     fn from(s: &'a S) -> Self {
         let s: &str = s.as_ref();
-        unsafe {
-            &*(s as *const str as *const OneShot<str>)
-        }
+        unsafe { &*(s as *const str as *const OneShot<str>) }
     }
 }
 
-impl Hash for OneShot<String>
-{
+impl Hash for OneShot<String> {
     fn hash<H: Hasher>(&self, h: &mut H) {
         h.write(self.0.as_bytes())
     }
 }
 
-impl Borrow<OneShot<str>> for OneShot<String>
-{
+impl Borrow<OneShot<str>> for OneShot<String> {
     fn borrow(&self) -> &OneShot<str> {
         <&OneShot<str>>::from(&self.0)
     }
 }
 
-impl<T> Deref for OneShot<T>
-{
+impl<T> Deref for OneShot<T> {
     type Target = T;
     fn deref(&self) -> &T {
         &self.0
     }
 }
 
-
 fn shuffled_keys<I>(iter: I) -> Vec<I::Item>
-    where I: IntoIterator
+where
+    I: IntoIterator,
 {
     let mut v = Vec::from_iter(iter);
     let mut rng = thread_rng();
     v.shuffle(&mut rng);
     v
 }
 
-
 #[bench]
 fn insert_hashmap_string_10_000(b: &mut Bencher) {
     let c = 10_000;
@@ -137,7 +131,9 @@ fn lookup_hashmap_10_000_exist_string_oneshot(b: &mut Bencher) {
     for &key in &keys {
         map.insert(OneShot(key.to_string()), 1);
     }
-    let lookups = (5000..c).map(|x| OneShot(x.to_string())).collect::<Vec<_>>();
+    let lookups = (5000..c)
+        .map(|x| OneShot(x.to_string()))
+        .collect::<Vec<_>>();
     b.iter(|| {
         let mut found = 0;
         for key in &lookups {
@@ -173,7 +169,9 @@ fn lookup_ordermap_10_000_exist_string_oneshot(b: &mut Bencher) {
     for &key in &keys {
         map.insert(OneShot(key.to_string()), 1);
     }
-    let lookups = (5000..c).map(|x| OneShot(x.to_string())).collect::<Vec<_>>();
+    let lookups = (5000..c)
+        .map(|x| OneShot(x.to_string()))
+        .collect::<Vec<_>>();
     b.iter(|| {
         let mut found = 0;
         for key in &lookups {

src/equivalent.rs

@@ -1,4 +1,3 @@
-
 use std::borrow::Borrow;
 
 /// Key equivalence trait.
@@ -17,8 +16,9 @@ pub trait Equivalent<K: ?Sized> {
 }
 
 impl<Q: ?Sized, K: ?Sized> Equivalent<K> for Q
-    where Q: Eq,
-          K: Borrow<Q>,
+where
+    Q: Eq,
+    K: Borrow<Q>,
 {
     #[inline]
     fn equivalent(&self, key: &K) -> bool {