0.3.2: less code is better code

Author: maciejhirsz

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "toolshed"
-version = "0.3.1"
+version = "0.3.2"
 authors = ["maciejhirsz <[email protected]>"]
 license = "MIT/Apache-2.0"
 description = "Arena allocator and a handful of useful data structures"
@@ -18,3 +18,6 @@ serde_json = "1.0"
 default = []
 
 impl_serialize = ["serde"]
+
+[profile.bench]
+lto = true

src/cell.rs

@@ -6,23 +6,21 @@ use std::marker::PhantomData;
 /// This should be identical to the `Cell` implementation in the standard
 /// library, but always require that the internal type implements `Copy`
 /// and implements `Copy` itself.
-#[derive(PartialEq)]
-pub struct CopyCell<T: Copy> {
+#[derive(PartialEq, Eq)]
+pub struct CopyCell<T> {
     /// Internal value
-    pub(crate) value: T,
+    value: T,
 
     /// We trick the compiler to think that `CopyCell` contains a raw pointer,
     /// this way we make sure the `Sync` marker is not implemented and `CopyCell`
     /// cannot be shared across threads!
-    pub(crate) _no_sync: PhantomData<*mut T>
+    _no_sync: PhantomData<*mut T>
 }
 
 /// `Sync` is unsafe due to mutability, however `Send` is totally fine!
-unsafe impl<T: Copy> Send for CopyCell<T> {}
+unsafe impl<T> Send for CopyCell<T> {}
 
-impl<T: Copy + Eq> Eq for CopyCell<T> {}
-
-impl<T: Copy> CopyCell<T> {
+impl<T> CopyCell<T> {
     /// Creates a new `CopyCell` containing the given value.
     #[inline]
     pub fn new(value: T) -> Self {
@@ -31,7 +29,9 @@ impl<T: Copy> CopyCell<T> {
             _no_sync: PhantomData
         }
     }
+}
 
+impl<T: Copy> CopyCell<T> {
     #[inline]
     fn mut_ptr(&self) -> *mut T {
         &self.value as *const T as *mut T
@@ -119,4 +119,13 @@ mod test {
         assert_eq!(cell_b.get(), 300);
         assert_eq!(cell_c.get(), 200);
     }
+
+    #[test]
+    fn contain_static_ref() {
+        static REF: &(&u64, u64) = &(&0, 0);
+
+        let cell = CopyCell::new(REF);
+
+        assert_eq!(cell.get(), REF);
+    }
 }

src/impl_debug.rs

@@ -1,12 +1,11 @@
 use std::fmt::{self, Debug};
-use std::hash::Hash;
 use list::List;
 use map::{Map, BloomMap};
 use set::{Set, BloomSet};
 
 impl<'arena, T> Debug for List<'arena, T>
 where
-    T: 'arena + Debug,
+    T: Debug,
 {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -16,8 +15,8 @@ where
 
 impl<'arena, K, V> Debug for Map<'arena, K, V>
 where
-    K: 'arena + Debug + Eq + Hash + Copy,
-    V: 'arena + Debug + Copy,
+    K: Debug,
+    V: Debug + Copy,
 {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -27,8 +26,8 @@ where
 
 impl<'arena, K, V> Debug for BloomMap<'arena, K, V>
 where
-    K: 'arena + Debug + Eq + Hash + Copy + AsRef<[u8]>,
-    V: 'arena + Debug + Copy,
+    K: Debug,
+    V: Debug + Copy,
 {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -38,7 +37,7 @@ where
 
 impl<'arena, I> Debug for Set<'arena, I>
 where
-    I: 'arena + Debug + Eq + Hash + Copy,
+    I: Debug,
 {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -48,7 +47,7 @@ where
 
 impl<'arena, I> Debug for BloomSet<'arena, I>
 where
-    I: 'arena + Debug + Eq + Hash + Copy + AsRef<[u8]>,
+    I: Debug,
 {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

src/impl_partial_eq.rs

@@ -1,56 +1,57 @@
-use std::hash::Hash;
 use list::List;
 use map::{Map, BloomMap};
 use set::{Set, BloomSet};
 
-impl<'arena, T> PartialEq for List<'arena, T>
+impl<'a, 'b, A, B> PartialEq<List<'b, B>> for List<'a, A>
 where
-    T: 'arena + PartialEq,
+    A: PartialEq<B>,
 {
     #[inline]
-    fn eq(&self, other: &Self) -> bool {
+    fn eq(&self, other: &List<'b, B>) -> bool {
         self.iter().eq(other.iter())
     }
 }
 
-impl<'arena, K, V> PartialEq for Map<'arena, K, V>
+impl<'a, 'b, KA, VA, KB, VB> PartialEq<Map<'b, KB, VB>> for Map<'a, KA, VA>
 where
-    K: 'arena + Eq + Hash + Copy,
-    V: 'arena + PartialEq + Copy,
+    (&'a KA, VA): PartialEq<(&'b KB, VB)>,
+    VA: Copy,
+    VB: Copy,
 {
     #[inline]
-    fn eq(&self, other: &Self) -> bool {
+    fn eq(&self, other: &Map<'b, KB, VB>) -> bool {
         self.iter().eq(other.iter())
     }
 }
 
-impl<'arena, K, V> PartialEq for BloomMap<'arena, K, V>
+impl<'a, 'b, KA, VA, KB, VB> PartialEq<BloomMap<'b, KB, VB>> for BloomMap<'a, KA, VA>
 where
-    K: 'arena + Eq + Hash + Copy + AsRef<[u8]>,
-    V: 'arena + PartialEq + Copy,
+    (&'a KA, VA): PartialEq<(&'b KB, VB)>,
+    VA: Copy,
+    VB: Copy,
 {
     #[inline]
-    fn eq(&self, other: &Self) -> bool {
+    fn eq(&self, other: &BloomMap<'b, KB, VB>) -> bool {
         self.iter().eq(other.iter())
     }
 }
 
-impl<'arena, I> PartialEq for Set<'arena, I>
+impl<'a, 'b, A, B> PartialEq<Set<'b, B>> for Set<'a, A>
 where
-    I: 'arena + Eq + Hash + Copy,
+    A: PartialEq<B>,
 {
     #[inline]
-    fn eq(&self, other: &Self) -> bool {
+    fn eq(&self, other: &Set<'b, B>) -> bool {
         self.iter().eq(other.iter())
     }
 }
 
-impl<'arena, I> PartialEq for BloomSet<'arena, I>
+impl<'a, 'b, A, B> PartialEq<BloomSet<'b, B>> for BloomSet<'a, A>
 where
-    I: 'arena + Eq + Hash + Copy + AsRef<[u8]>,
+    A: PartialEq<B>,
 {
     #[inline]
-    fn eq(&self, other: &Self) -> bool {
+    fn eq(&self, other: &BloomSet<'b, B>) -> bool {
         self.iter().eq(other.iter())
     }
 }

src/impl_serialize.rs

@@ -1,4 +1,3 @@
-use std::hash::Hash;
 use serde::ser::{Serialize, Serializer};
 use list::List;
 use map::{Map, BloomMap};
@@ -19,8 +18,8 @@ where
 
 impl<'arena, K, V> Serialize for Map<'arena, K, V>
 where
-    K: 'arena + Serialize + Eq + Hash + Copy,
-    V: 'arena + Serialize + Copy,
+    K: Serialize,
+    V: Serialize + Copy,
 {
     #[inline]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -33,8 +32,8 @@ where
 
 impl<'arena, K, V> Serialize for BloomMap<'arena, K, V>
 where
-    K: 'arena + Serialize + Eq + Hash + Copy + AsRef<[u8]>,
-    V: 'arena + Serialize + Copy,
+    K: Serialize,
+    V: Serialize + Copy,
 {
     #[inline]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -47,7 +46,7 @@ where
 
 impl<'arena, I> Serialize for Set<'arena, I>
 where
-    I: 'arena + Serialize + Eq + Hash + Copy,
+    I: Serialize,
 {
     #[inline]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -60,7 +59,7 @@ where
 
 impl<'arena, I> Serialize for BloomSet<'arena, I>
 where
-    I: 'arena + Serialize + Eq + Hash + Copy + AsRef<[u8]>,
+    I: Serialize,
 {
     #[inline]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

src/list.rs

@@ -9,6 +9,8 @@ pub struct List<'arena, T: 'arena> {
     root: CopyCell<Option<&'arena ListItem<'arena, T>>>,
 }
 
+impl<'arena, T: Copy> Copy for List<'arena, T> { }
+
 impl<'arena, T: 'arena> List<'arena, T> {
     /// Create a new empty `List`.
     #[inline]
@@ -143,7 +145,6 @@ impl<'arena, T: 'arena + Copy> List<'arena, T> {
     }
 }
 
-
 impl<'arena, T: 'arena> IntoIterator for List<'arena, T> {
     type Item = &'arena T;
     type IntoIter = ListIter<'arena, T>;
@@ -164,7 +165,6 @@ impl<'a, 'arena, T: 'arena> IntoIterator for &'a List<'arena, T> {
     }
 }
 
-impl<'arena, T: Copy> Copy for List<'arena, T> { }
 
 #[derive(Debug, PartialEq, Clone)]
 struct ListItem<'arena, T: 'arena> {