From 60f391c38b548f5134addb116d2adcfa18ba3367 Mon Sep 17 00:00:00 2001
From: Steven Fackler <sfackler@gmail.com>
Date: Thu, 17 Jul 2014 19:12:42 -0700
Subject: [PATCH 01/12] Yay index

---
 phf_mac/src/lib.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/phf_mac/src/lib.rs b/phf_mac/src/lib.rs
index d519be4..8e5f17b 100644
--- a/phf_mac/src/lib.rs
+++ b/phf_mac/src/lib.rs
@@ -366,11 +366,11 @@ fn try_generate_hash(entries: &[Entry], rng: &mut XorShiftRng)
             'disps: for d2 in range(0, table_len) {
                 try_map.clear();
                 for &key in bucket.keys.iter() {
-                    let idx = shared::displace(hashes.get(key).f1,
-                                               hashes.get(key).f2,
+                    let idx = shared::displace(hashes[key].f1,
+                                               hashes[key].f2,
                                                d1,
                                                d2) % table_len;
-                    if map.get(idx).is_some() || try_map.find(&idx).is_some() {
+                    if map[idx].is_some() || try_map.find(&idx).is_some() {
                         continue 'disps;
                     }
                     try_map.insert(idx, key);
@@ -405,7 +405,7 @@ fn create_map(cx: &mut ExtCtxt, sp: Span, entries: Vec<Entry>, state: HashState)
     let disps = create_slice_expr(disps, sp);
 
     let entries = state.map.iter().map(|&idx| {
-        let &Entry { key, value, .. } = entries.get(idx);
+        let &Entry { key, value, .. } = &entries[idx];
         quote_expr!(&*cx, ($key, $value))
     }).collect();
     let entries = create_slice_expr(entries, sp);

From 5c59a7a15d0ba8278ff96a33f7b86bfb8733f4b9 Mon Sep 17 00:00:00 2001
From: Steven Fackler <sfackler@gmail.com>
Date: Fri, 18 Jul 2014 09:12:31 -0700
Subject: [PATCH 02/12] Update for API changes

---
 phf_mac/src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/phf_mac/src/lib.rs b/phf_mac/src/lib.rs
index 8e5f17b..75a505c 100644
--- a/phf_mac/src/lib.rs
+++ b/phf_mac/src/lib.rs
@@ -166,7 +166,7 @@ fn parse_map(cx: &mut ExtCtxt, tts: &[TokenTree]) -> Option<Vec<Entry>> {
     let mut bad = false;
     while parser.token != EOF {
         let key = cx.expand_expr(parser.parse_expr());
-        let key_contents = parse_key(cx, key).unwrap_or_else(|| {
+        let key_contents = parse_key(cx, &*key).unwrap_or_else(|| {
             bad = true;
             KeyStr(InternedString::new(""))
         });
@@ -213,7 +213,7 @@ fn parse_set(cx: &mut ExtCtxt, tts: &[TokenTree]) -> Option<Vec<Entry>> {
     let mut bad = false;
     while parser.token != EOF {
         let key = cx.expand_expr(parser.parse_expr());
-        let key_contents = parse_key(cx, key).unwrap_or_else(|| {
+        let key_contents = parse_key(cx, &*key).unwrap_or_else(|| {
             bad = true;
             KeyStr(InternedString::new(""))
         });

From 3995dbc443f33571e15c18c45b38862a515a88c0 Mon Sep 17 00:00:00 2001
From: Steven Fackler <sfackler@gmail.com>
Date: Sat, 19 Jul 2014 14:21:58 -0700
Subject: [PATCH 03/12] Impl Index for PhfMap and PhfOrderedMap

---
 phf/src/lib.rs  | 12 ++++++++++++
 phf/src/test.rs | 34 ++++++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+)

diff --git a/phf/src/lib.rs b/phf/src/lib.rs
index aeaa2f3..be5c53c 100644
--- a/phf/src/lib.rs
+++ b/phf/src/lib.rs
@@ -83,6 +83,12 @@ impl<K: fmt::Show, V: fmt::Show> fmt::Show for PhfMap<K, V> {
     }
 }
 
+impl<K: Hash+Eq, V> Index<K, V> for PhfMap<K, V> {
+    fn index<'a>(&'a self, k: &K) -> &'a V {
+        self.find(k).expect("invalid key")
+    }
+}
+
 impl<K: Hash+Eq, V> PhfMap<K, V> {
     fn get_entry<'a, T: Hash>(&'a self, key: &T, check: |&K| -> bool)
                               -> Option<&'a (K, V)> {
@@ -404,6 +410,12 @@ impl<'a, K: Hash+Eq, V> Map<K, V> for PhfOrderedMap<K, V> {
     }
 }
 
+impl<K: Hash+Eq, V> Index<K, V> for PhfOrderedMap<K, V> {
+    fn index<'a>(&'a self, k: &K) -> &'a V {
+        self.find(k).expect("invalid key")
+    }
+}
+
 impl<K: Hash+Eq, V> PhfOrderedMap<K, V> {
     fn find_entry<'a>(&'a self, key: &K) -> Option<&'a (K, V)> {
         let (g, f1, f2) = shared::hash(key, self.k1, self.k2);
diff --git a/phf/src/test.rs b/phf/src/test.rs
index ee95a99..2587e31 100644
--- a/phf/src/test.rs
+++ b/phf/src/test.rs
@@ -115,6 +115,23 @@ mod map {
         assert_eq!(Some(&0), map.find_equiv(&"a".to_string().as_slice()));
     }
 
+    #[test]
+    fn test_index_ok() {
+        static map: PhfMap<&'static str, int> = phf_map!(
+            "a" => 0,
+        );
+        assert_eq!(0, map["a"]);
+    }
+
+    #[test]
+    #[should_fail]
+    fn test_index_fail() {
+        static map: PhfMap<&'static str, int> = phf_map!(
+            "a" => 0,
+        );
+        map["b"];
+    }
+
     macro_rules! test_key_type(
         ($t:ty, $($k:expr => $v:expr),+) => ({
             static map: PhfMap<$t, int> = phf_map! {
@@ -283,6 +300,23 @@ mod ordered_map {
         let vec = MAP.values().map(|&v| v).collect::<Vec<_>>();
         assert_eq!(vec, vec!(10i, 11, 12));
     }
+
+    #[test]
+    fn test_index_ok() {
+        static map: PhfOrderedMap<&'static str, int> = phf_ordered_map!(
+            "a" => 0,
+        );
+        assert_eq!(0, map["a"]);
+    }
+
+    #[test]
+    #[should_fail]
+    fn test_index_fail() {
+        static map: PhfOrderedMap<&'static str, int> = phf_ordered_map!(
+            "a" => 0,
+        );
+        map["b"];
+    }
 }
 
 mod ordered_set {

From 20a1e838c01017d74ef48cdb40e30eaf32de834a Mon Sep 17 00:00:00 2001
From: Steven Fackler <sfackler@gmail.com>
Date: Mon, 21 Jul 2014 22:15:37 -0700
Subject: [PATCH 04/12] Elide lifetimes

I'm not eliding struct lifetime parameters because that makes things
confusing IMO
---
 phf/src/lib.rs | 30 ++++++++++++++----------------
 1 file changed, 14 insertions(+), 16 deletions(-)

diff --git a/phf/src/lib.rs b/phf/src/lib.rs
index be5c53c..486fae9 100644
--- a/phf/src/lib.rs
+++ b/phf/src/lib.rs
@@ -60,7 +60,7 @@ impl<K, V> Collection for PhfMap<K, V> {
 }
 
 impl<'a, K: Hash+Eq, V> Map<K, V> for PhfMap<K, V> {
-    fn find<'a>(&'a self, key: &K) -> Option<&'a V> {
+    fn find(&self, key: &K) -> Option<&V> {
         self.get_entry(key, |k| key == k).map(|e| {
             let &(_, ref v) = e;
             v
@@ -84,14 +84,14 @@ impl<K: fmt::Show, V: fmt::Show> fmt::Show for PhfMap<K, V> {
 }
 
 impl<K: Hash+Eq, V> Index<K, V> for PhfMap<K, V> {
-    fn index<'a>(&'a self, k: &K) -> &'a V {
+    fn index(&self, k: &K) -> &V {
         self.find(k).expect("invalid key")
     }
 }
 
 impl<K: Hash+Eq, V> PhfMap<K, V> {
-    fn get_entry<'a, T: Hash>(&'a self, key: &T, check: |&K| -> bool)
-                              -> Option<&'a (K, V)> {
+    fn get_entry<T: Hash>(&self, key: &T, check: |&K| -> bool)
+                          -> Option<&(K, V)> {
         let (g, f1, f2) = shared::hash(key, self.k1, self.k2);
         let (d1, d2) = self.disps[g % self.disps.len()];
         let entry @ &(ref s, _) = &self.entries[shared::displace(f1, f2, d1, d2) %
@@ -107,7 +107,7 @@ impl<K: Hash+Eq, V> PhfMap<K, V> {
     /// key.
     ///
     /// This can be useful for interning schemes.
-    pub fn find_key<'a>(&'a self, key: &K) -> Option<&'a K> {
+    pub fn find_key(&self, key: &K) -> Option<&K> {
         self.get_entry(key, |k| key == k).map(|e| {
             let &(ref k, _) = e;
             k
@@ -115,8 +115,7 @@ impl<K: Hash+Eq, V> PhfMap<K, V> {
     }
 
     /// Like `find`, but can operate on any type that is equivalent to a key.
-    pub fn find_equiv<'a, T: Hash+Equiv<K>>(&'a self, key: &T)
-                                            -> Option<&'a V> {
+    pub fn find_equiv<T: Hash+Equiv<K>>(&self, key: &T) -> Option<&V> {
         self.get_entry(key, |k| key.equiv(k)).map(|e| {
             let &(_, ref v) = e;
             v
@@ -125,8 +124,7 @@ impl<K: Hash+Eq, V> PhfMap<K, V> {
 
     /// Like `find_key`, but can operate on any type that is equivalent to a
     /// key.
-    pub fn find_key_equiv<'a, T: Hash+Equiv<K>>(&'a self, key: &T)
-                                                -> Option<&'a K> {
+    pub fn find_key_equiv<T: Hash+Equiv<K>>(&self, key: &T) -> Option<&K> {
         self.get_entry(key, |k| key.equiv(k)).map(|e| {
             let &(ref k, _) = e;
             k
@@ -301,7 +299,7 @@ impl<T: Hash+Eq> PhfSet<T> {
     ///
     /// This can be useful for interning schemes.
     #[inline]
-    pub fn find_key<'a>(&'a self, key: &T) -> Option<&'a T> {
+    pub fn find_key(&self, key: &T) -> Option<&T> {
         self.map.find_key(key)
     }
 }
@@ -401,8 +399,8 @@ impl<K, V> Collection for PhfOrderedMap<K, V> {
     }
 }
 
-impl<'a, K: Hash+Eq, V> Map<K, V> for PhfOrderedMap<K, V> {
-    fn find<'a>(&'a self, key: &K) -> Option<&'a V> {
+impl<K: Hash+Eq, V> Map<K, V> for PhfOrderedMap<K, V> {
+    fn find(&self, key: &K) -> Option<&V> {
         self.find_entry(key).map(|e| {
             let &(_, ref v) = e;
             v
@@ -411,13 +409,13 @@ impl<'a, K: Hash+Eq, V> Map<K, V> for PhfOrderedMap<K, V> {
 }
 
 impl<K: Hash+Eq, V> Index<K, V> for PhfOrderedMap<K, V> {
-    fn index<'a>(&'a self, k: &K) -> &'a V {
+    fn index(&self, k: &K) -> &V {
         self.find(k).expect("invalid key")
     }
 }
 
 impl<K: Hash+Eq, V> PhfOrderedMap<K, V> {
-    fn find_entry<'a>(&'a self, key: &K) -> Option<&'a (K, V)> {
+    fn find_entry(&self, key: &K) -> Option<&(K, V)> {
         let (g, f1, f2) = shared::hash(key, self.k1, self.k2);
         let (d1, d2) = self.disps[g % self.disps.len()];
         let idx = self.idxs[shared::displace(f1, f2, d1, d2) % self.idxs.len()];
@@ -434,7 +432,7 @@ impl<K: Hash+Eq, V> PhfOrderedMap<K, V> {
     /// key.
     ///
     /// This can be useful for interning schemes.
-    pub fn find_key<'a>(&'a self, key: &K) -> Option<&'a K> {
+    pub fn find_key(&self, key: &K) -> Option<&K> {
         self.find_entry(key).map(|e| {
             let &(ref k, _) = e;
             k
@@ -644,7 +642,7 @@ impl<T: Hash+Eq> PhfOrderedSet<T> {
     ///
     /// This can be useful for interning schemes.
     #[inline]
-    pub fn find_key<'a>(&'a self, key: &T) -> Option<&'a T> {
+    pub fn find_key(&self, key: &T) -> Option<&T> {
         self.map.find_key(key)
     }
 }

From eeec95c7da4dd4fe29813c1a18722b9314320436 Mon Sep 17 00:00:00 2001
From: Steven Fackler <sfackler@gmail.com>
Date: Wed, 23 Jul 2014 18:27:10 -0700
Subject: [PATCH 05/12] Update for libsyntax changes

---
 phf_mac/src/lib.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/phf_mac/src/lib.rs b/phf_mac/src/lib.rs
index 75a505c..e92fbaf 100644
--- a/phf_mac/src/lib.rs
+++ b/phf_mac/src/lib.rs
@@ -24,6 +24,7 @@ use syntax::ext::base::{DummyResult,
                         ExtCtxt,
                         MacResult,
                         MacExpr};
+use syntax::fold::Folder;
 use syntax::parse;
 use syntax::parse::token::{InternedString, COMMA, EOF, FAT_ARROW};
 use syntax::print::pprust;
@@ -165,7 +166,7 @@ fn parse_map(cx: &mut ExtCtxt, tts: &[TokenTree]) -> Option<Vec<Entry>> {
 
     let mut bad = false;
     while parser.token != EOF {
-        let key = cx.expand_expr(parser.parse_expr());
+        let key = cx.expander().fold_expr(parser.parse_expr());
         let key_contents = parse_key(cx, &*key).unwrap_or_else(|| {
             bad = true;
             KeyStr(InternedString::new(""))
@@ -212,7 +213,7 @@ fn parse_set(cx: &mut ExtCtxt, tts: &[TokenTree]) -> Option<Vec<Entry>> {
 
     let mut bad = false;
     while parser.token != EOF {
-        let key = cx.expand_expr(parser.parse_expr());
+        let key = cx.expander().fold_expr(parser.parse_expr());
         let key_contents = parse_key(cx, &*key).unwrap_or_else(|| {
             bad = true;
             KeyStr(InternedString::new(""))

From c98c691225ad80fe3962ff4390393afebc327ebb Mon Sep 17 00:00:00 2001
From: Steven Fackler <sfackler@gmail.com>
Date: Thu, 24 Jul 2014 09:15:47 -0700
Subject: [PATCH 06/12] Fix README example

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 7241b86..8eceaca 100644
--- a/README.md
+++ b/README.md
@@ -33,6 +33,6 @@ static KEYWORDS: PhfMap<&'static str, Keyword> = phf_map! {
 };
 
 pub fn parse_keyword(keyword: &str) -> Option<Keyword> {
-    KEYWORDS.find(keyword).map(|t| t.clone())
+    KEYWORDS.find_equiv(keyword).map(|t| t.clone())
 }
 ```

From 61eea759b53785fd8233a565de0765ce66fb824d Mon Sep 17 00:00:00 2001
From: Steven Fackler <sfackler@gmail.com>
Date: Thu, 24 Jul 2014 22:28:08 -0700
Subject: [PATCH 07/12] Add more _equiv methods

This should be enough to do everything you'd be able to do before

Closes #8
---
 phf/src/lib.rs  | 90 ++++++++++++++++++++++++++++++++++++++-----------
 phf/src/test.rs | 26 ++++++++++++++
 2 files changed, 97 insertions(+), 19 deletions(-)

diff --git a/phf/src/lib.rs b/phf/src/lib.rs
index 486fae9..2352c91 100644
--- a/phf/src/lib.rs
+++ b/phf/src/lib.rs
@@ -90,6 +90,19 @@ impl<K: Hash+Eq, V> Index<K, V> for PhfMap<K, V> {
 }
 
 impl<K: Hash+Eq, V> PhfMap<K, V> {
+    /// Returns a reference to the map's internal static instance of the given
+    /// key.
+    ///
+    /// This can be useful for interning schemes.
+    pub fn find_key(&self, key: &K) -> Option<&K> {
+        self.get_entry(key, |k| key == k).map(|e| {
+            let &(ref k, _) = e;
+            k
+        })
+    }
+}
+
+impl<K, V> PhfMap<K, V> {
     fn get_entry<T: Hash>(&self, key: &T, check: |&K| -> bool)
                           -> Option<&(K, V)> {
         let (g, f1, f2) = shared::hash(key, self.k1, self.k2);
@@ -103,17 +116,6 @@ impl<K: Hash+Eq, V> PhfMap<K, V> {
         }
     }
 
-    /// Returns a reference to the map's internal static instance of the given
-    /// key.
-    ///
-    /// This can be useful for interning schemes.
-    pub fn find_key(&self, key: &K) -> Option<&K> {
-        self.get_entry(key, |k| key == k).map(|e| {
-            let &(ref k, _) = e;
-            k
-        })
-    }
-
     /// Like `find`, but can operate on any type that is equivalent to a key.
     pub fn find_equiv<T: Hash+Equiv<K>>(&self, key: &T) -> Option<&V> {
         self.get_entry(key, |k| key.equiv(k)).map(|e| {
@@ -304,6 +306,22 @@ impl<T: Hash+Eq> PhfSet<T> {
     }
 }
 
+impl<T> PhfSet<T> {
+    /// Like `contains`, but can operate on any type that is equivalent to a
+    /// value
+    #[inline]
+    pub fn contains_equiv<U: Hash+Equiv<T>>(&self, key: &U) -> bool {
+        self.map.find_equiv(key).is_some()
+    }
+
+    /// Like `find_key`, but can operate on any type that is equivalent to a
+    /// value
+    #[inline]
+    pub fn find_key_equiv<U: Hash+Equiv<T>>(&self, key: &U) -> Option<&T> {
+        self.map.find_key_equiv(key)
+    }
+}
+
 impl<T> PhfSet<T> {
     /// Returns an iterator over the values in the set.
     ///
@@ -401,7 +419,7 @@ impl<K, V> Collection for PhfOrderedMap<K, V> {
 
 impl<K: Hash+Eq, V> Map<K, V> for PhfOrderedMap<K, V> {
     fn find(&self, key: &K) -> Option<&V> {
-        self.find_entry(key).map(|e| {
+        self.find_entry(key, |k| k == key).map(|e| {
             let &(_, ref v) = e;
             v
         })
@@ -415,25 +433,45 @@ impl<K: Hash+Eq, V> Index<K, V> for PhfOrderedMap<K, V> {
 }
 
 impl<K: Hash+Eq, V> PhfOrderedMap<K, V> {
-    fn find_entry(&self, key: &K) -> Option<&(K, V)> {
+    /// Returns a reference to the map's internal static instance of the given
+    /// key.
+    ///
+    /// This can be useful for interning schemes.
+    pub fn find_key(&self, key: &K) -> Option<&K> {
+        self.find_entry(key, |k| k == key).map(|e| {
+            let &(ref k, _) = e;
+            k
+        })
+    }
+}
+
+impl<K, V> PhfOrderedMap<K, V> {
+    fn find_entry<T: Hash>(&self, key: &T, check: |&K| -> bool)
+                           -> Option<&(K, V)> {
         let (g, f1, f2) = shared::hash(key, self.k1, self.k2);
         let (d1, d2) = self.disps[g % self.disps.len()];
         let idx = self.idxs[shared::displace(f1, f2, d1, d2) % self.idxs.len()];
         let entry @ &(ref s, _) = &self.entries[idx];
 
-        if s == key {
+        if check(s) {
             Some(entry)
         } else {
             None
         }
     }
 
-    /// Returns a reference to the map's internal static instance of the given
+    /// Like `find`, but can operate on any type that is equivalent to a key.
+    pub fn find_equiv<T: Hash+Equiv<K>>(&self, key: &T) -> Option<&V> {
+        self.find_entry(key, |k| key.equiv(k)).map(|e| {
+            let &(_, ref v) = e;
+            v
+        })
+    }
+
+    /// Like `find_key`, but can operate on any type that is equivalent to a
     /// key.
-    ///
-    /// This can be useful for interning schemes.
-    pub fn find_key(&self, key: &K) -> Option<&K> {
-        self.find_entry(key).map(|e| {
+    pub fn find_key_equiv<T: Hash+Equiv<K>>(&self, key: &T) -> Option<&K> {
+        self.find_entry(key, |k| key.equiv(k)).map(|e| {
             let &(ref k, _) = e;
             k
         })
@@ -648,6 +686,20 @@ impl<T: Hash+Eq> PhfOrderedSet<T> {
 }
 
 impl<T> PhfOrderedSet<T> {
+    /// Like `contains`, but can operate on any type that is equivalent to a
+    /// value
+    #[inline]
+    pub fn contains_equiv<U: Hash+Equiv<T>>(&self, key: &U) -> bool {
+        self.map.find_equiv(key).is_some()
+    }
+
+    /// Like `find_key`, but can operate on any type that is equivalent to a
+    /// value
+    #[inline]
+    pub fn find_key_equiv<U: Hash+Equiv<T>>(&self, key: &U) -> Option<&T> {
+        self.map.find_key_equiv(key)
+    }
+
     /// Returns an iterator over the values in the set.
     ///
     /// Values are returned in the same order in which they were defined.
diff --git a/phf/src/test.rs b/phf/src/test.rs
index 2587e31..edfa789 100644
--- a/phf/src/test.rs
+++ b/phf/src/test.rs
@@ -241,6 +241,15 @@ mod set {
         assert!(set.contains(&"world"));
         assert_eq!(2, set.len());
     }
+
+    #[test]
+    fn test_non_static_str_contains() {
+        static SET: PhfSet<&'static str> = phf_set! {
+            "hello",
+            "world",
+        };
+        assert!(SET.contains_equiv(&"hello".to_string().as_slice()));
+    }
 }
 
 mod ordered_map {
@@ -317,6 +326,14 @@ mod ordered_map {
         );
         map["b"];
     }
+
+    #[test]
+    fn test_non_static_str_key() {
+        static map: PhfOrderedMap<&'static str, int> = phf_ordered_map!(
+            "a" => 0,
+        );
+        assert_eq!(Some(&0), map.find_equiv(&"a".to_string().as_slice()));
+    }
 }
 
 mod ordered_set {
@@ -356,4 +373,13 @@ mod ordered_set {
         let vec = SET.iter().map(|&e| e).collect::<Vec<_>>();
         assert_eq!(vec, vec!("hello", "there", "world"));
     }
+
+    #[test]
+    fn test_non_static_str_contains() {
+        static SET: PhfOrderedSet<&'static str> = phf_ordered_set! {
+            "hello",
+            "world",
+        };
+        assert!(SET.contains_equiv(&"hello".to_string().as_slice()));
+    }
 }

From c9ca9b118f77e0581887c0bde09e78f9f7f00d0f Mon Sep 17 00:00:00 2001
From: Steven Fackler <sfackler@gmail.com>
Date: Thu, 24 Jul 2014 22:52:47 -0700
Subject: [PATCH 08/12] Move test to tests dir

---
 phf/Cargo.toml             | 5 -----
 phf/{src => tests}/test.rs | 0
 2 files changed, 5 deletions(-)
 rename phf/{src => tests}/test.rs (100%)

diff --git a/phf/Cargo.toml b/phf/Cargo.toml
index f0471ad..2386374 100644
--- a/phf/Cargo.toml
+++ b/phf/Cargo.toml
@@ -13,8 +13,3 @@ test = false
 [dev_dependencies.phf_mac]
 
 path = "../phf_mac"
-
-[[test]]
-
-name = "test"
-path = "src/test.rs"
\ No newline at end of file
diff --git a/phf/src/test.rs b/phf/tests/test.rs
similarity index 100%
rename from phf/src/test.rs
rename to phf/tests/test.rs

From f79814a6abfa3bc5d739825643ea4ecee0a3aa8a Mon Sep 17 00:00:00 2001
From: Steven Fackler <sfackler@gmail.com>
Date: Fri, 1 Aug 2014 22:26:38 -0700
Subject: [PATCH 09/12] Update for pattern changes

---
 phf/src/lib.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/phf/src/lib.rs b/phf/src/lib.rs
index 2352c91..ddad4fa 100644
--- a/phf/src/lib.rs
+++ b/phf/src/lib.rs
@@ -107,8 +107,9 @@ impl<K, V> PhfMap<K, V> {
                           -> Option<&(K, V)> {
         let (g, f1, f2) = shared::hash(key, self.k1, self.k2);
         let (d1, d2) = self.disps[g % self.disps.len()];
-        let entry @ &(ref s, _) = &self.entries[shared::displace(f1, f2, d1, d2) %
-                                                self.entries.len()];
+        let entry = &self.entries[shared::displace(f1, f2, d1, d2) %
+                                  self.entries.len()];
+        let &(ref s, _) = entry;
         if check(s) {
             Some(entry)
         } else {
@@ -451,7 +452,8 @@ impl<K, V> PhfOrderedMap<K, V> {
         let (g, f1, f2) = shared::hash(key, self.k1, self.k2);
         let (d1, d2) = self.disps[g % self.disps.len()];
         let idx = self.idxs[shared::displace(f1, f2, d1, d2) % self.idxs.len()];
-        let entry @ &(ref s, _) = &self.entries[idx];
+        let entry = &self.entries[idx];
+        let &(ref s, _) = entry;
 
         if check(s) {
             Some(entry)

From 4e45f668a97e88198f16ef29603249c0dc0451fd Mon Sep 17 00:00:00 2001
From: Steven Fackler <sfackler@gmail.com>
Date: Sun, 3 Aug 2014 19:10:31 -0700
Subject: [PATCH 10/12] Remove Makefile infrastructure

Woo Cargo!
---
 .gitignore  |  2 --
 Makefile.in | 57 -----------------------------------------------------
 configure   | 20 -------------------
 3 files changed, 79 deletions(-)
 delete mode 100644 Makefile.in
 delete mode 100755 configure

diff --git a/.gitignore b/.gitignore
index b71287e..eb9b86a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,3 @@
-/build/
 /doc/
-/Makefile
 /phf/target/
 /phf_mac/target/
diff --git a/Makefile.in b/Makefile.in
deleted file mode 100644
index 29eceee..0000000
--- a/Makefile.in
+++ /dev/null
@@ -1,57 +0,0 @@
-RUSTC := rustc
-BUILDDIR := build
-RUSTFLAGS := -O --cfg ndebug
-INSTALL_DIR := %PREFIX%
-LD_LIBRARY_PATH := $(LD_LIBRARY_PATH):build
-ENV := LD_LIBRARY_PATH=$(LD_LIBRARY_PATH) DYLD_LIBRARY_PATH=$(LD_LIBRARY_PATH)
-
-PHF_LIB := phf/src/lib.rs
-PHF := $(foreach file,$(shell $(RUSTC) --print-file-name $(PHF_LIB)),$(BUILDDIR)/$(file))
-PHF_MAC_LIB := phf_mac/src/lib.rs
-PHF_MAC := $(BUILDDIR)/$(shell $(RUSTC) --print-file-name $(PHF_MAC_LIB))
-PHF_TEST_MAIN := phf/src/test.rs
-PHF_TEST := $(BUILDDIR)/$(shell $(RUSTC) --print-file-name $(PHF_TEST_MAIN))
-
-all: $(PHF) $(PHF_MAC)
-
--include $(BUILDDIR)/phf.d
--include $(BUILDDIR)/phf_mac.d
--include $(BUILDDIR)/phf_test.d
-
-$(BUILDDIR):
-	mkdir -p $@
-
-.NOTPARALLEL: $(PHF)
-
-$(PHF): $(PHF_LIB) | $(BUILDDIR)
-	$(ENV) $(RUSTC) $(RUSTFLAGS) --dep-info $(BUILDDIR)/phf.d --out-dir $(@D) $<
-
-$(PHF_MAC): $(PHF_MAC_LIB) | $(BUILDDIR)
-	$(ENV) $(RUSTC) $(RUSTFLAGS) --dep-info $(BUILDDIR)/phf_mac.d --out-dir $(@D) \
-		-L $(BUILDDIR) $<
-
-$(PHF_TEST): $(PHF_TEST_MAIN) $(PHF) $(PHF_MAC) | $(BUILDDIR)
-	$(ENV) $(RUSTC) --test $(RUSTFLAGS) -L $(BUILDDIR) \
-		--dep-info $(BUILDDIR)/phf_test.d --out-dir $(@D) $<
-
-doc-test: $(PHF) $(PHF_MAC)
-	rustdoc -L $(BUILDDIR) --test $(PHF_LIB)
-
-check: $(PHF_TEST) doc-test
-	$(PHF_TEST)
-
-doc: $(PHF)
-	$(ENV) rustdoc $(PHF_LIB)
-	$(ENV) rustdoc -L $(BUILDDIR) $(PHF_MAC_LIB)
-
-install: $(PHF) $(PHF_MAC)
-	install $(PHF) $(INSTALL_DIR)
-	install $(PHF_MAC) $(INSTALL_DIR)
-
-clean:
-	rm -rf $(BUILDDIR)
-
-print-targets:
-	@echo $(PHF_MAC) $(PHF)
-
-.PHONY: all doc-test check doc install clean print-targets
diff --git a/configure b/configure
deleted file mode 100755
index 7fe7f2b..0000000
--- a/configure
+++ /dev/null
@@ -1,20 +0,0 @@
-#!/bin/bash
-
-cd $(dirname $0)
-
-TEMP=`getopt -o "" --long prefix: -n "$0" -- "$@"`
-
-if [ $? != 0 ]; then exit 1; fi
-
-eval set -- "$TEMP"
-
-PREFIX=/usr/lib
-
-while true ; do
-    case "$1" in
-        --prefix) PREFIX=$2; shift 2;;
-        --) shift; break;;
-    esac
-done
-
-sed -e "s|%PREFIX%|$PREFIX|" < Makefile.in > Makefile

From fa5d803428dd760287330571c919c7c5e11b2e1b Mon Sep 17 00:00:00 2001
From: Steven Fackler <sfackler@gmail.com>
Date: Sun, 3 Aug 2014 19:18:15 -0700
Subject: [PATCH 11/12] Ignore lockfile

---
 .gitignore | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.gitignore b/.gitignore
index eb9b86a..1689f08 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,3 @@
-/doc/
-/phf/target/
-/phf_mac/target/
+doc/
+target/
+Cargo.lock

From 6bcf4146652a9868bc64c2835f7770c8a7007e93 Mon Sep 17 00:00:00 2001
From: Jack Moffitt <jack@metajack.im>
Date: Wed, 6 Aug 2014 10:23:57 -0600
Subject: [PATCH 12/12] Fixup Makefile after merge.

---
 Makefile.in | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile.in b/Makefile.in
index 3fb2896..1df717e 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -8,7 +8,7 @@ HOST_RUSTFLAGS ?= -O
 
 PHF_SRC := $(VPATH)/phf/src/lib.rs
 PHF_MAC_SRC := $(VPATH)/phf_mac/src/lib.rs
-PHF_TEST_SRC := $(VPATH)/phf/src/test.rs
+PHF_TEST_SRC := $(VPATH)/phf/tests/test.rs
 
 all: phf.dummy phf_host.dummy phf_mac.dummy