Fixes for min const generics

Author: korken89

Cargo.toml

@@ -32,8 +32,7 @@ __trybuild = []
 scoped_threadpool = "0.1.8"
 
 [dependencies]
-as-slice = "0.1.0"
-# generic-array = "0.13.0"
+as-slice = "0.2.0"
 hash32 = "0.1.0"
 
 [dependencies.serde]

src/binary_heap.rs

@@ -72,20 +72,12 @@ pub enum Max {}
 /// assert!(heap.is_empty())
 /// ```
 
-pub struct BinaryHeap<T, K, const N: usize>
-where
-    T: Ord,
-    K: Kind,
-{
+pub struct BinaryHeap<T, K, const N: usize> {
     pub(crate) _kind: PhantomData<K>,
     pub(crate) data: Vec<T, N>,
 }
 
-impl<T, K, const N: usize> BinaryHeap<T, K, N>
-where
-    T: Ord,
-    K: Kind,
-{
+impl<T, K, const N: usize> BinaryHeap<T, K, N> {
     /* Constructors */
     /// Creates an empty BinaryHeap as a $K-heap.
     ///
@@ -105,7 +97,13 @@ where
             data: Vec::new(),
         }
     }
+}
 
+impl<T, K, const N: usize> BinaryHeap<T, K, N>
+where
+    T: Ord,
+    K: Kind,
+{
     /* Public API */
     /// Returns the capacity of the binary heap.
     pub fn capacity(&self) -> usize {
@@ -512,11 +510,7 @@ where
     }
 }
 
-impl<T, K, const N: usize> Drop for BinaryHeap<T, K, N>
-where
-    K: Kind,
-    T: Ord,
-{
+impl<T, K, const N: usize> Drop for BinaryHeap<T, K, N> {
     fn drop(&mut self) {
         unsafe { ptr::drop_in_place(self.data.as_mut_slice()) }
     }

src/i.rs

@@ -67,17 +67,13 @@
 //! It *might* compile on older versions but that may change in any new patch release.
 
 // experimental usage of const generics, requires nightly 2020-08-18 (or newer)
-#![feature(min_const_generics)]
-#![feature(const_fn)]
 #![cfg_attr(not(test), no_std)]
 #![deny(missing_docs)]
 #![deny(rust_2018_compatibility)]
 #![deny(rust_2018_idioms)]
 // #![deny(warnings)]
 
 pub use binary_heap::BinaryHeap;
-// pub use generic_array::typenum::{consts, PowerOfTwo};
-// pub use generic_array::ArrayLength;
 pub use histbuf::HistoryBuffer;
 pub use indexmap::{Bucket, FnvIndexMap, IndexMap, Pos};
 pub use indexset::{FnvIndexSet, IndexSet};
@@ -99,10 +95,9 @@ mod de;
 mod ser;
 
 pub mod binary_heap;
-// pub mod i;
 #[cfg(all(has_cas, feature = "cas"))]
 pub mod mpmc;
-// #[cfg(all(has_cas, feature = "cas"))]
+#[cfg(all(has_cas, feature = "cas"))]
 pub mod pool;
 #[cfg(has_atomics)]
 pub mod spsc;

src/lib.rs

@@ -12,17 +12,11 @@ use crate::Vec;
 ///
 /// Note that as this map doesn't use hashing so most operations are **O(N)** instead of O(1)
 
-pub struct LinearMap<K, V, const N: usize>
-where
-    K: Eq,
-{
+pub struct LinearMap<K, V, const N: usize> {
     pub(crate) buffer: Vec<(K, V), N>,
 }
 
-impl<K, V, const N: usize> LinearMap<K, V, N>
-where
-    K: Eq,
-{
+impl<K, V, const N: usize> LinearMap<K, V, N> {
     /// Creates an empty `LinearMap`
     ///
     /// # Examples
@@ -39,7 +33,12 @@ where
     pub const fn new() -> Self {
         Self { buffer: Vec::new() }
     }
+}
 
+impl<K, V, const N: usize> LinearMap<K, V, N>
+where
+    K: Eq,
+{
     /// Returns the number of elements that the map can hold
     ///
     /// Computes in **O(1)** time
@@ -437,25 +436,6 @@ where
     }
 }
 
-// TODO: Why is this needed at all, no example, no test... I don't get it
-// impl<K, V, const N: usize> IntoIterator for LinearMap<K, V, N>
-// where
-//     K: Eq,
-// {
-//     type Item = (K, V);
-//     type IntoIter = IntoIter<K, V, N>;
-
-//     fn into_iter(mut self) -> Self::IntoIter {
-//         // FIXME this may result in a memcpy at runtime
-//         let lm = mem::replace(&mut self, unsafe { MaybeUninit::uninit().assume_init() });
-//         mem::forget(self);
-
-//         Self::IntoIter {
-//             inner: lm.buffer.into_iter(),
-//         }
-//     }
-// }
-
 impl<'a, K, V, const N: usize> IntoIterator for &'a LinearMap<K, V, N>
 where
     K: Eq,
@@ -488,10 +468,7 @@ impl<'a, K, V> Clone for Iter<'a, K, V> {
     }
 }
 
-impl<K, V, const N: usize> Drop for LinearMap<K, V, N>
-where
-    K: Eq,
-{
+impl<K, V, const N: usize> Drop for LinearMap<K, V, N> {
     fn drop(&mut self) {
         // heapless::Vec implements drop right?
         drop(&self.buffer);