but how is perf like this

Signed-off-by: Adam Gutglick <adam@spiraldb.com>

Author: AdamGS

encodings/fastlanes/src/bitpacking/compute/compare.rs

@@ -80,14 +80,14 @@ where
         + FastLanesComparable<Bitpacked = <T as PhysicalPType>::Physical>,
     <T as PhysicalPType>::Physical: BitPacking + NativePType + BitPackingCompare,
 {
-    #[cfg(debug_assertions)]
+    // #[cfg(debug_assertions)]
     {
         // FastLanes expands `unchecked_unpack_cmp` by width, value type, and comparator type.
         // In dev builds, using one function-pointer comparator type avoids multiplying that
         // generated code and debug info by every comparison operator.
         let cmp: fn(T, T) -> bool = match operator {
             CompareOperator::Eq => NativePType::is_eq,
-            CompareOperator::NotEq => not_eq::<T>,
+            CompareOperator::NotEq => |a, b| !NativePType::is_eq(a, b),
             CompareOperator::Lt => NativePType::is_lt,
             CompareOperator::Lte => NativePType::is_le,
             CompareOperator::Gt => NativePType::is_gt,
@@ -96,34 +96,29 @@ where
         stream_compare_fused::<T, fn(T, T) -> bool>(lhs, rhs, nullability, cmp, ctx)
     }
 
-    #[cfg(not(debug_assertions))]
-    {
-        match operator {
-            CompareOperator::Eq => {
-                stream_compare_fused::<T, _>(lhs, rhs, nullability, |a, b| a.is_eq(b), ctx)
-            }
-            CompareOperator::NotEq => {
-                stream_compare_fused::<T, _>(lhs, rhs, nullability, |a, b| !a.is_eq(b), ctx)
-            }
-            CompareOperator::Lt => {
-                stream_compare_fused::<T, _>(lhs, rhs, nullability, |a, b| a.is_lt(b), ctx)
-            }
-            CompareOperator::Lte => {
-                stream_compare_fused::<T, _>(lhs, rhs, nullability, |a, b| a.is_le(b), ctx)
-            }
-            CompareOperator::Gt => {
-                stream_compare_fused::<T, _>(lhs, rhs, nullability, |a, b| a.is_gt(b), ctx)
-            }
-            CompareOperator::Gte => {
-                stream_compare_fused::<T, _>(lhs, rhs, nullability, |a, b| a.is_ge(b), ctx)
-            }
-        }
-    }
-}
-
-#[cfg(debug_assertions)]
-fn not_eq<T: NativePType>(lhs: T, rhs: T) -> bool {
-    !lhs.is_eq(rhs)
+    // #[cfg(not(debug_assertions))]
+    // {
+    //     match operator {
+    //         CompareOperator::Eq => {
+    //             stream_compare_fused::<T, _>(lhs, rhs, nullability, |a, b| a.is_eq(b), ctx)
+    //         }
+    //         CompareOperator::NotEq => {
+    //             stream_compare_fused::<T, _>(lhs, rhs, nullability, |a, b| !a.is_eq(b), ctx)
+    //         }
+    //         CompareOperator::Lt => {
+    //             stream_compare_fused::<T, _>(lhs, rhs, nullability, |a, b| a.is_lt(b), ctx)
+    //         }
+    //         CompareOperator::Lte => {
+    //             stream_compare_fused::<T, _>(lhs, rhs, nullability, |a, b| a.is_le(b), ctx)
+    //         }
+    //         CompareOperator::Gt => {
+    //             stream_compare_fused::<T, _>(lhs, rhs, nullability, |a, b| a.is_gt(b), ctx)
+    //         }
+    //         CompareOperator::Gte => {
+    //             stream_compare_fused::<T, _>(lhs, rhs, nullability, |a, b| a.is_ge(b), ctx)
+    //         }
+    //     }
+    // }
 }
 
 #[cfg(test)]