Format using rustfmt

Author: michaelsproul

examples/string_frequency.rs

@@ -16,7 +16,7 @@ fn main() {
             // Append all chars in a to the String
             s.extend(a);
             // If the value at s exists, add 1. Otherwise, assign 1 as the key's value.
-            trie.map_with_default(s, |v| { *v += 1; }, 1);
+            trie.map_with_default(s, |v| *v += 1, 1);
         }
     }
 

src/iter.rs

@@ -1,10 +1,10 @@
 //! Iterators over key-value pairs, keys, values and child subtries.
 
+use std::iter::{FilterMap, FromIterator, Map};
 use std::slice;
-use std::iter::{Map, FilterMap, FromIterator};
 
-use {Trie, TrieKey, SubTrie, NibbleVec};
 use trie_node::TrieNode;
+use {NibbleVec, SubTrie, Trie, TrieKey};
 
 // MY EYES.
 type Child<K, V> = Box<TrieNode<K, V>>;
@@ -42,7 +42,9 @@ impl<'a, K, V> Keys<'a, K, V> {
         fn first<'b, K, V>((k, _): (&'b K, &'b V)) -> &'b K {
             k
         }
-        Keys { inner: iter.map(first) }
+        Keys {
+            inner: iter.map(first),
+        }
     }
 }
 
@@ -66,7 +68,9 @@ impl<'a, K, V> Values<'a, K, V> {
         fn second<'b, K, V>((_, v): (&'b K, &'b V)) -> &'b V {
             v
         }
-        Values { inner: iter.map(second) }
+        Values {
+            inner: iter.map(second),
+        }
     }
 }
 
@@ -97,11 +101,9 @@ impl<'a, K, V> Iterator for Children<'a, K, V> {
     type Item = SubTrie<'a, K, V>;
 
     fn next(&mut self) -> Option<SubTrie<'a, K, V>> {
-        self.inner.next().map(|node| {
-            SubTrie {
-                prefix: self.prefix.clone().join(&node.key),
-                node: node,
-            }
+        self.inner.next().map(|node| SubTrie {
+            prefix: self.prefix.clone().join(&node.key),
+            node: node,
         })
     }
 }
@@ -144,12 +146,10 @@ impl<'a, K, V> Iterator for Iter<'a, K, V> {
 
         loop {
             let action = match self.stack.last_mut() {
-                Some(stack_top) => {
-                    match stack_top.next() {
-                        Some(child) => Push(child),
-                        None => Pop,
-                    }
-                }
+                Some(stack_top) => match stack_top.next() {
+                    Some(child) => Push(child),
+                    None => Pop,
+                },
                 None => return None,
             };
 
@@ -169,10 +169,12 @@ impl<'a, K, V> Iterator for Iter<'a, K, V> {
 }
 
 impl<K, V> FromIterator<(K, V)> for Trie<K, V>
-    where K: TrieKey
+where
+    K: TrieKey,
 {
     fn from_iter<T>(iter: T) -> Trie<K, V>
-        where T: IntoIterator<Item = (K, V)>
+    where
+        T: IntoIterator<Item = (K, V)>,
     {
         let mut trie = Trie::new();
         for (k, v) in iter {

src/keys.rs

@@ -1,7 +1,7 @@
-use NibbleVec;
-use endian_type::{LittleEndian, BigEndian};
+use endian_type::{BigEndian, LittleEndian};
 use std::ffi::OsString;
 use std::path::{Path, PathBuf};
+use NibbleVec;
 
 /// Trait for types which can be used to key a Radix Trie.
 ///
@@ -65,7 +65,8 @@ pub fn match_keys(start_idx: usize, first: &NibbleVec, second: &NibbleVec) -> Ke
 
 /// Check two keys for equality and panic if they differ.
 pub fn check_keys<K: ?Sized>(key1: &K, key2: &K)
-    where K: TrieKey
+where
+    K: TrieKey,
 {
     if *key1 != *key2 {
         panic!("multiple-keys with the same bit representation.");
@@ -81,7 +82,6 @@ pub fn check_keys<K: ?Sized>(key1: &K, key2: &K)
 // }
 // }
 
-
 impl TrieKey for Vec<u8> {
     fn encode_bytes(&self) -> Vec<u8> {
         self.clone()
@@ -138,7 +138,7 @@ impl TrieKey for u8 {
 impl TrieKey for PathBuf {
     fn encode_bytes(&self) -> Vec<u8> {
         use std::os::unix::ffi::OsStringExt;
-        let str : OsString = self.clone().into();
+        let str: OsString = self.clone().into();
         str.into_vec()
     }
 }
@@ -152,15 +152,17 @@ impl TrieKey for Path {
 }
 
 impl<T> TrieKey for LittleEndian<T>
-    where T: Eq + Copy
+where
+    T: Eq + Copy,
 {
     fn encode_bytes(&self) -> Vec<u8> {
         self.as_bytes().encode_bytes()
     }
 }
 
 impl<T> TrieKey for BigEndian<T>
-    where T: Eq + Copy
+where
+    T: Eq + Copy,
 {
     fn encode_bytes(&self) -> Vec<u8> {
         self.as_bytes().to_vec()

src/lib.rs

@@ -4,34 +4,34 @@
 
 // #![warn(missing_docs)]
 
-extern crate nibble_vec;
 extern crate endian_type;
+extern crate nibble_vec;
 #[cfg(test)]
 extern crate quickcheck;
 #[cfg(test)]
 extern crate rand;
 
-pub use nibble_vec::NibbleVec;
 pub use keys::TrieKey;
+pub use nibble_vec::NibbleVec;
 pub use trie_common::TrieCommon;
 use trie_node::TrieNode;
 
 #[macro_use]
 mod macros;
-mod keys;
 pub mod iter;
+mod keys;
+#[cfg(feature = "serde")]
+mod serde;
+mod subtrie;
 mod traversal;
 mod trie;
-mod subtrie;
-mod trie_node;
 mod trie_common;
-#[cfg(feature = "serde")]
-mod serde;
+mod trie_node;
 
-#[cfg(test)]
-mod test;
 #[cfg(test)]
 mod qc_test;
+#[cfg(test)]
+mod test;
 
 const BRANCH_FACTOR: usize = 16;
 

src/macros.rs

@@ -1,4 +1,6 @@
 // Identity macro to allow expansion of the "mutability" token tree.
 macro_rules! id {
-    ($e:item) => { $e }
+    ($e:item) => {
+        $e
+    };
 }

src/qc_test.rs

@@ -1,9 +1,9 @@
 //! Proper testing, with QuickCheck.
 
-use {Trie, TrieKey, TrieCommon};
+use quickcheck::{quickcheck, Arbitrary, Gen};
+use std::collections::{HashMap, HashSet};
 use std::iter::FromIterator;
-use std::collections::{HashSet, HashMap};
-use quickcheck::{quickcheck, Gen, Arbitrary};
+use {Trie, TrieCommon, TrieKey};
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 struct Key(Vec<u8>);
@@ -188,18 +188,16 @@ fn subtrie_mut_get() {
 
 #[test]
 fn subtrie_insert() {
-    fn prop(
-        trie_keys: RandomKeys,
-        key_suffixes: RandomKeys,
-        k1: Key
-    ) -> bool {
+    fn prop(trie_keys: RandomKeys, key_suffixes: RandomKeys, k1: Key) -> bool {
         let mut trie = length_trie(trie_keys.0);
         trie.insert(k1.clone(), k1.len());
 
         {
             let mut subtrie = trie.subtrie_mut(&k1).unwrap();
 
-            let insert_keys = key_suffixes.0.into_iter()
+            let insert_keys = key_suffixes
+                .0
+                .into_iter()
                 .map(|x| k1.extend(x))
                 .collect::<HashSet<_>>();
 
@@ -210,7 +208,7 @@ fn subtrie_insert() {
             for k in insert_keys.iter() {
                 match subtrie.get(k) {
                     Ok(Some(_)) => (),
-                    _ => return false
+                    _ => return false,
                 }
             }
         }

src/serde.rs

@@ -1,17 +1,19 @@
 extern crate serde;
 
-use super::{Trie, TrieKey, TrieCommon};
-use self::serde::{Serialize, Serializer, Deserialize, Deserializer, de};
 use self::serde::ser::SerializeMap;
-use std::marker::PhantomData;
+use self::serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+use super::{Trie, TrieCommon, TrieKey};
 use std::fmt::{self, Formatter};
+use std::marker::PhantomData;
 
 impl<K, V> Serialize for Trie<K, V>
-    where K: Serialize + TrieKey,
-          V: Serialize
+where
+    K: Serialize + TrieKey,
+    V: Serialize,
 {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where S: Serializer
+    where
+        S: Serializer,
     {
         let mut map = serializer.serialize_map(Some(self.len()))?;
         for (k, v) in self.iter() {
@@ -21,20 +23,22 @@ impl<K, V> Serialize for Trie<K, V>
     }
 }
 
-
 struct TrieVisitor<K, V> {
     marker: PhantomData<Trie<K, V>>,
 }
 
 impl<K, V> TrieVisitor<K, V> {
     fn new() -> Self {
-        TrieVisitor { marker: PhantomData }
+        TrieVisitor {
+            marker: PhantomData,
+        }
     }
 }
 
 impl<'a, K, V> de::Visitor<'a> for TrieVisitor<K, V>
-    where K: Deserialize<'a> + Clone + Eq + PartialEq + TrieKey,
-          V: Deserialize<'a>
+where
+    K: Deserialize<'a> + Clone + Eq + PartialEq + TrieKey,
+    V: Deserialize<'a>,
 {
     type Value = Trie<K, V>;
 
@@ -43,7 +47,8 @@ impl<'a, K, V> de::Visitor<'a> for TrieVisitor<K, V>
     }
 
     fn visit_map<M>(self, mut visitor: M) -> Result<Self::Value, M::Error>
-        where M: de::MapAccess<'a>
+    where
+        M: de::MapAccess<'a>,
     {
         let mut values = Trie::new();
 
@@ -55,18 +60,21 @@ impl<'a, K, V> de::Visitor<'a> for TrieVisitor<K, V>
     }
 
     fn visit_unit<E>(self) -> Result<Self::Value, E>
-        where E: de::Error
+    where
+        E: de::Error,
     {
         Ok(Trie::new())
     }
 }
 
 impl<'a, K, V> Deserialize<'a> for Trie<K, V>
-    where K: Deserialize<'a> + Clone + Eq + PartialEq + TrieKey,
-          V: Deserialize<'a>
+where
+    K: Deserialize<'a> + Clone + Eq + PartialEq + TrieKey,
+    V: Deserialize<'a>,
 {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where D: Deserializer<'a>
+    where
+        D: Deserializer<'a>,
     {
         // Instantiate our Visitor and ask the Deserializer to drive
         // it over the input data, resulting in an instance of MyMap.
@@ -77,7 +85,7 @@ impl<'a, K, V> Deserialize<'a> for Trie<K, V>
 #[cfg(test)]
 mod test {
     extern crate serde_test;
-    use self::serde_test::{Token};
+    use self::serde_test::Token;
     use super::super::Trie;
 
     macro_rules! tests_de {