Always check bounds on inserting, no UB necessary fixed yegor256#193

src/lib.rs

@@ -92,9 +92,7 @@ use core::mem::MaybeUninit;
 ///
 /// It is also faster because it doesn't grow in size. When a [`Map`] is created,
 /// its size is fixed on stack. If an attempt is made to insert too many keys
-/// into it, it simply panics. Moreover, in the "release" mode it doesn't panic,
-/// but its behaviour is undefined. In the "release" mode all boundary checks
-/// are disabled, for the sake of higher performance.
+/// into it, it simply panics.
 pub struct Map<K: PartialEq, V, const N: usize> {
     /// The next available pair in the array.
     len: usize,

src/map.rs

@@ -151,10 +151,7 @@ impl<K: PartialEq, V, const N: usize> Map<K, V, N> {
     ///
     /// # Panics
     ///
-    /// It may panic if there are too many pairs in the map already. Pay attention,
-    /// it panics only in the "debug" mode. In the "release" mode, you are going to get
-    /// undefined behavior. This is done for the sake of performance, in order to
-    /// avoid a repetitive check for the boundary condition on every `insert()`.
+    /// It may panic if there are too many pairs in the map already.
     #[inline]
     pub fn insert(&mut self, k: K, v: V) -> Option<V> {
         let (_, existing_value) = self.insert_i(k, v);
@@ -168,8 +165,7 @@ impl<K: PartialEq, V, const N: usize> Map<K, V, N> {
         let mut existing_value = None;
         loop {
             if i == self.len {
-                #[cfg(feature = "std")]
-                debug_assert!(target < N, "No more keys available in the map");
+                assert!(target < N, "No more keys available in the map");
                 break;
             }
             let p = self.item_ref(i);

src/set/functions.rs

@@ -80,10 +80,7 @@ impl<T: PartialEq, const N: usize> Set<T, N> {
     ///
     /// # Panics
     ///
-    /// It may panic if there are too many pairs in the set already. Pay attention,
-    /// it panics only in the "debug" mode. In the "release" mode, you are going to get
-    /// undefined behavior. This is done for the sake of performance, in order to
-    /// avoid a repetitive check for the boundary condition on every `insert()`.
+    /// It may panic if there are too many pairs in the set already.
     #[inline]
     pub fn insert(&mut self, k: T) -> bool {
         self.map.insert(k, ()).is_none()

src/set/mod.rs

@@ -34,9 +34,7 @@ use crate::Map;
 ///
 /// It is also faster because it doesn't grow in size. When a [`Set`] is created,
 /// its size is fixed on stack. If an attempt is made to insert too many keys
-/// into it, it simply panics. Moreover, in the "release" mode it doesn't panic,
-/// but its behaviour is undefined. In the "release" mode all boundary checks
-/// are disabled, for the sake of higher performance.
+/// into it, it simply panics.
 #[repr(transparent)]
 pub struct Set<T: PartialEq, const N: usize> {
     map: Map<T, (), N>,