Formatting, linting

Author: feikesteenbergen

.cargo/config.toml

@@ -0,0 +1 @@
+config

crates/asap/src/lib.rs

@@ -100,7 +100,7 @@ fn binary_search(
     let mut min_obj = min_obj;
     let mut window_size = window_size;
     while head <= tail {
-        let w = (head + tail + 1) / 2;
+        let w = (head + tail).div_ceil(2);
         let smoothed = sma(data, w, 1);
         let metrics = Metrics::new(&smoothed);
         if metrics.kurtosis() >= original_kurt {
@@ -238,7 +238,7 @@ struct Metrics<'a> {
     m: f64,
 }
 
-impl<'a> Metrics<'a> {
+impl Metrics<'_> {
     fn new(values: &[f64]) -> Metrics {
         Metrics {
             len: values.len() as u32,

crates/encodings/src/lib.rs

@@ -107,21 +107,21 @@ pub mod zigzag {
 }
 
 pub mod prefix_varint {
-    /// Similar to [LEB128](https://en.wikipedia.org/wiki/LEB128), but it moves
-    /// all the tag bits to the LSBs of the first byte, which ends up looking
-    /// like this (`x` is a value bit, the rest are tag bits):
-    /// ```python,ignore,no_run
-    /// xxxxxxx1  7 bits in 1 byte
-    /// xxxxxx10 14 bits in 2 bytes
-    /// xxxxx100 21 bits in 3 bytes
-    /// xxxx1000 28 bits in 4 bytes
-    /// xxx10000 35 bits in 5 bytes
-    /// xx100000 42 bits in 6 bytes
-    /// x1000000 49 bits in 7 bytes
-    /// 10000000 56 bits in 8 bytes
-    /// 00000000 64 bits in 9 bytes
-    /// ```
-    /// based on https://github.com/stoklund/varint
+    //! Similar to [LEB128](https://en.wikipedia.org/wiki/LEB128), but it moves
+    //! all the tag bits to the LSBs of the first byte, which ends up looking
+    //! like this (`x` is a value bit, the rest are tag bits):
+    //! ```python,ignore,no_run
+    //! xxxxxxx1  7 bits in 1 byte
+    //! xxxxxx10 14 bits in 2 bytes
+    //! xxxxx100 21 bits in 3 bytes
+    //! xxxx1000 28 bits in 4 bytes
+    //! xxx10000 35 bits in 5 bytes
+    //! xx100000 42 bits in 6 bytes
+    //! x1000000 49 bits in 7 bytes
+    //! 10000000 56 bits in 8 bytes
+    //! 00000000 64 bits in 9 bytes
+    //! ```
+    //! based on https://github.com/stoklund/varint
 
     pub fn size_vec<I: Iterator<Item = u64>>(bytes: &mut Vec<u8>, values: I) {
         let size: usize = values.map(|v| bytes_for_value(v) as usize).sum();

crates/flat_serialize/flat_serialize/src/lib.rs

@@ -242,7 +242,7 @@ pub enum Iter<'input, 'borrow, T: 'input> {
     Owned(std::vec::IntoIter<T>),
 }
 
-impl<'input, 'borrow, T: 'input> Iterator for Iter<'input, 'borrow, T>
+impl<'input, T: 'input> Iterator for Iter<'input, '_, T>
 where
     T: FlatSerializable<'input> + Clone,
 {
@@ -288,7 +288,7 @@ where
     }
 }
 
-impl<'input, 'borrow, T: 'input> Iter<'input, 'borrow, T>
+impl<'input, T: 'input> Iter<'input, '_, T>
 where
     T: FlatSerializable<'input> + Clone,
 {
@@ -492,7 +492,7 @@ where
     }
 }
 
-impl<'de, 'i, T> serde::Deserialize<'de> for Slice<'i, T>
+impl<'de, T> serde::Deserialize<'de> for Slice<'_, T>
 where
     T: serde::Deserialize<'de>,
 {

crates/flat_serialize/flat_serialize_macro/src/lib.rs

@@ -1392,7 +1392,7 @@ pub fn flat_serializable_derive(input: TokenStream) -> TokenStream {
                         Ok(meta) => meta,
                         _ => return None,
                     };
-                    let has_repr = meta.path().get_ident().map_or(false, |id| id == "repr");
+                    let has_repr = meta.path().get_ident().is_some_and(|id| id == "repr");
                     if !has_repr {
                         return None;
                     }
@@ -1501,7 +1501,7 @@ pub fn flat_serializable_derive(input: TokenStream) -> TokenStream {
                 Ok(meta) => meta,
                 _ => return None,
             };
-            let has_repr = meta.path().get_ident().map_or(false, |id| id == "repr");
+            let has_repr = meta.path().get_ident().is_some_and(|id| id == "repr");
             if !has_repr {
                 return None;
             }

crates/flat_serialize/flat_serialize_macro/src/parser.rs

@@ -329,7 +329,7 @@ fn validate_self_field(
 
 struct ValidateLenFields<'a, 'b>(Option<TokenStream2>, &'b HashSet<&'a Ident>);
 
-impl<'a, 'b, 'ast> Visit<'ast> for ValidateLenFields<'a, 'b> {
+impl<'ast> Visit<'ast> for ValidateLenFields<'_, '_> {
     fn visit_expr(&mut self, expr: &'ast syn::Expr) {
         if self.0.is_some() {
             return;

crates/hyperloglogplusplus/src/lib.rs

@@ -123,7 +123,7 @@ impl<'s, T, B> HyperLogLog<'s, T, B> {
     }
 }
 
-impl<'s, T, B> HyperLogLog<'s, T, B>
+impl<T, B> HyperLogLog<'_, T, B>
 where
     T: Hash + ?Sized,
     B: BuildHasher,

crates/stats-agg/src/stats2d.rs

@@ -519,11 +519,12 @@ impl<T: FloatLike> StatsSummary2D<T> {
             y: self.sy / self.n64(),
         })
     }
+
     ///returns the count of inputs as an i64
     ///```
     /// use stats_agg::stats2d::StatsSummary2D;
     /// use stats_agg::XYPair;
-
+    ///
     /// let p = StatsSummary2D::new_from_vec(vec![XYPair{y:2.0, x:1.0,}, XYPair{y:4.0, x:2.0,}, XYPair{y:6.0, x:3.0,}]).unwrap();
     /// let s = 3;
     /// assert_eq!(p.count(), s);

crates/udd-sketch/src/lib.rs

@@ -5,7 +5,7 @@ use serde::{Deserialize, Serialize};
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
 
-use crate::SketchHashKey::Zero;
+use crate::SketchHashKey::Invalid;
 #[cfg(test)]
 use ordered_float::OrderedFloat;
 #[cfg(test)]
@@ -110,7 +110,7 @@ pub struct SketchHashIterator<'a> {
     next_key: SketchHashKey,
 }
 
-impl<'a> Iterator for SketchHashIterator<'a> {
+impl Iterator for SketchHashIterator<'_> {
     type Item = (SketchHashKey, u64);
 
     fn next(&mut self) -> Option<(SketchHashKey, u64)> {
@@ -284,7 +284,7 @@ impl SketchHashMap {
         entries[old_index] = current;
 
         // We should only return the slice containing the aggregated values
-        let iter = entries.into_iter().take(old_index + 1).peekable();
+        let iter = entries.iter_mut().take(old_index + 1).peekable();
 
         let mut iter = iter.peekable();
         self.head = iter.peek().map(|p| p.0).unwrap_or(Invalid);
@@ -304,7 +304,7 @@ impl SketchHashMap {
     #[inline]
     fn compact(&mut self) {
         match self.len() {
-            0 => return,
+            0 => (),
             // PERCENTILE_AGG_DEFAULT_SIZE defaults to 200, so
             // this entry covers that case.
             1..=200 => self.compact_using_stack::<200>(),
@@ -344,7 +344,8 @@ impl UDDSketch {
             alpha: initial_error,
             gamma: (1.0 + initial_error) / (1.0 - initial_error),
             compactions: 0,
-            max_buckets: NonZeroU32::new(max_buckets as u32).expect("max buckets should be greater than zero"),
+            max_buckets: NonZeroU32::new(max_buckets)
+                .expect("max buckets should be greater than zero"),
             num_values: 0,
             values_sum: 0.0,
         }
@@ -361,8 +362,7 @@ impl UDDSketch {
             buckets: SketchHashMap::with_capacity(capacity),
             alpha: metadata.current_error,
             gamma: gamma(metadata.current_error),
-            compactions: u8::try_from(metadata.compactions)
-                .expect("compactions cannot be higher than 65"),
+            compactions: metadata.compactions,
             max_buckets: NonZeroU32::new(metadata.max_buckets)
                 .expect("max buckets should be greater than zero"),
             num_values: metadata.values,
@@ -376,7 +376,7 @@ impl UDDSketch {
 
         // This assumes the keys are unique and sorted
         while let (Some(key), Some(count)) = (keys.next(), counts.next()) {
-            let next = keys.peek().map(|k| *k).unwrap_or(Invalid);
+            let next = keys.peek().copied().unwrap_or(Invalid);
             sketch
                 .buckets
                 .map
@@ -876,13 +876,13 @@ mod tests {
 
         for i in 0..100 {
             assert!(((sketch.estimate_quantile((i as f64 + 1.0) / 100.0) / bounds[i]) - 1.0).abs() < sketch.max_error() * bounds[i].abs(),
-            "Failed to correct match {} quantile with seed {}.  Received: {}, Expected: {}, Error: {}, Expected error bound: {}",
-            (i as f64 + 1.0) / 100.0,
-            seed,
-            sketch.estimate_quantile((i as f64 + 1.0) / 100.0),
-            bounds[i],
-            ((sketch.estimate_quantile((i as f64 + 1.0) / 100.0) / bounds[i]) - 1.0).abs() / bounds[i].abs(),
-            sketch.max_error());
+                        "Failed to correct match {} quantile with seed {}.  Received: {}, Expected: {}, Error: {}, Expected error bound: {}",
+                        (i as f64 + 1.0) / 100.0,
+                        seed,
+                        sketch.estimate_quantile((i as f64 + 1.0) / 100.0),
+                        bounds[i],
+                        ((sketch.estimate_quantile((i as f64 + 1.0) / 100.0) / bounds[i]) - 1.0).abs() / bounds[i].abs(),
+                        sketch.max_error());
         }
     }
 

extension/src/asap.rs

@@ -117,7 +117,7 @@ fn asap_final_inner(
                 })
                 .collect();
 
-            let nulls_len = (points.len() + 7) / 8;
+            let nulls_len = points.len().div_ceil(8);
 
             Some(crate::build! {
                 Timevector_TSTZ_F64 {
@@ -165,7 +165,7 @@ pub fn asap_on_timevector(
         })
         .collect();
 
-    let nulls_len = (points.len() + 7) / 8;
+    let nulls_len = points.len().div_ceil(8);
 
     Some(crate::build! {
         Timevector_TSTZ_F64 {