chore: Formatting README.md, clippy lint

Author: St4NNi

README.md

@@ -3,8 +3,6 @@
 [![Crates.io](https://img.shields.io/crates/v/jam-rs.svg)](https://crates.io/crates/jam-rs)
 [![Codecov](https://codecov.io/github/St4NNi/jam-rs/coverage.svg?branch=main)](https://codecov.io/gh/St4NNi/jam-rs)
 [![Dependency status](https://deps.rs/repo/github/St4NNi/jam-rs/status.svg)](https://deps.rs/repo/github/St4NNi/jam-rs)
-___
-
 # jam-rs
 
 Just another minhash (jam) implementation. A high performance minhash variant to screen extremely large (metagenomic) datasets in a very short timeframe.

src/compare.rs

@@ -183,20 +183,18 @@ impl<'a> Comparator<'a> {
                     if self.reverse {
                         if !larger_stats.compare(smaller_stats, self.gc_bounds) {
                             self.num_skipped += 1;
-                        }else{
+                        } else {
                             self.num_common += 1;
                         }
+                    } else if !smaller_stats.compare(larger_stats, self.gc_bounds) {
+                        self.num_skipped += 1;
                     } else {
-                        if !smaller_stats.compare(larger_stats, self.gc_bounds) {
-                            self.num_skipped += 1;
-                        }else{
-                            self.num_common += 1;
-                        }
+                        self.num_common += 1;
                     }
                 };
             }
         } else {
-            for (hash, _) in &self.smaller.hashes {
+            for hash in self.smaller.hashes.keys() {
                 self.num_kmers += 1;
                 if self.larger.hashes.contains_key(hash) {
                     self.num_common += 1;
@@ -247,10 +245,7 @@ impl<'a> Comparator<'a> {
 mod tests {
     use std::collections::HashMap;
 
-    use crate::{
-        compare::CompareResult,
-        signature::Signature, sketch::Stats,
-    };
+    use crate::{compare::CompareResult, signature::Signature, sketch::Stats};
 
     use super::MultiComp;
 
@@ -362,6 +357,9 @@ mod tests {
         };
         assert_eq!(res[0], expected);
 
-        assert_eq!(res[0].to_string(), "test\ttest2\t2\t4\t50\t50\t2".to_string());
+        assert_eq!(
+            res[0].to_string(),
+            "test\ttest2\t2\t4\t50\t50\t2".to_string()
+        );
     }
 }

src/hash_functions.rs

@@ -23,7 +23,7 @@ pub fn xxhash3_u64(kmer: u64) -> u64 {
 pub fn ahash(kmer: u64) -> u64 {
     let temp = (kmer ^ KEY1) as u128 * 6364136223846793005_u128;
     let temp2 = ((temp & 0xffff_ffff_ffff_ffff) as u64) ^ ((temp >> 64) as u64); // XOR the lower 64 bits with the upper 64 bits.
-    return temp2.rotate_left(KEY2);
+    temp2.rotate_left(KEY2)
 }
 
 // Faster version of murmur3 with equivalent output
@@ -108,13 +108,25 @@ mod tests {
     #[test]
     fn function_test() {
         let f = Function::from_alg(HashAlgorithms::Ahash, 21);
-        assert_eq!(f.get_small().unwrap()(0xAAAAAAAAAAAAAAA), 6369629604220809163);
+        assert_eq!(
+            f.get_small().unwrap()(0xAAAAAAAAAAAAAAA),
+            6369629604220809163
+        );
         let f = Function::from_alg(HashAlgorithms::Murmur3, 21);
-        assert_eq!(f.get_small().unwrap()(0xAAAAAAAAAAAAAAA), 442865051503200633);
+        assert_eq!(
+            f.get_small().unwrap()(0xAAAAAAAAAAAAAAA),
+            442865051503200633
+        );
         let f = Function::from_alg(HashAlgorithms::Xxhash, 21);
-        assert_eq!(f.get_small().unwrap()(0xAAAAAAAAAAAAAAA), 5855080426738543665);
+        assert_eq!(
+            f.get_small().unwrap()(0xAAAAAAAAAAAAAAA),
+            5855080426738543665
+        );
         let f = Function::from_alg(HashAlgorithms::Default, 21);
-        assert_eq!(f.get_small().unwrap()(0xAAAAAAAAAAAAAAA), 6369629604220809163);
+        assert_eq!(
+            f.get_small().unwrap()(0xAAAAAAAAAAAAAAA),
+            6369629604220809163
+        );
         let f = Function::from_alg(HashAlgorithms::Murmur3, 32);
         assert_eq!(f.get_large().unwrap()(b"AAAAAAAAAAA"), 7773142420371383521);
         let f = Function::from_alg(HashAlgorithms::Xxhash, 32);

src/signature.rs

@@ -16,18 +16,18 @@ pub struct Signature {
     pub max_hash: u64,
 }
 
-impl Into<SourmashSignature> for Signature {
-    fn into(self) -> SourmashSignature {
+impl From<Signature> for SourmashSignature {
+    fn from(val: Signature) -> Self {
         SourmashSignature::builder()
-            .hash_function(format!("{:?}", self.algorithm))
-            .filename(Some(self.file_name))
+            .hash_function(format!("{:?}", val.algorithm))
+            .filename(Some(val.file_name))
             .email("".to_string())
             .license("CC0".to_string())
             .name(None)
             .signatures(
-                self.sketches
+                val.sketches
                     .into_iter()
-                    .map(|sketch| sketch.into_sourmash(self.max_hash))
+                    .map(|sketch| sketch.into_sourmash(val.max_hash))
                     .collect(),
             )
             .build()

src/sketcher.rs

@@ -27,20 +27,16 @@ struct SketchHelper {
 
 impl SketchHelper {
     pub fn new(kmer_budget: u64, max_hash: u64, nmin: Option<u64>, nmax: Option<u64>) -> Self {
-        let local_heap = if let Some(nmin) = nmin {
-            Some((nmin, BinaryHeap::with_capacity((nmin * 2) as usize)))
-        } else {
-            None
-        };
+        let local_heap = nmin.map(|nmin| (nmin, BinaryHeap::with_capacity((nmin * 2) as usize)));
 
         SketchHelper {
             kmer_budget,
             nmax,
             global_counter: 0,
             kmer_seq_counter: 0,
-            max_hash: max_hash,
+            max_hash,
             last_max_hash: 0,
-            global_heap: BinaryHeap::with_capacity(10_000_000 as usize),
+            global_heap: BinaryHeap::with_capacity(10_000_000_usize),
             local_heap,
             hashes: HashMap::with_capacity_and_hasher(
                 10_000_000,
@@ -79,17 +75,15 @@ impl SketchHelper {
                         self.hashes.remove(&max);
                     }
                 }
+            } else if self.global_heap.len() < self.kmer_budget as usize {
+                self.global_heap.push(hash);
+                self.hashes.insert(hash, self.current_stat.clone());
             } else {
-                if self.global_heap.len() < self.kmer_budget as usize {
-                    self.global_heap.push(hash);
+                let mut max = self.global_heap.peek_mut().unwrap();
+                if hash < *max {
+                    *max = hash;
                     self.hashes.insert(hash, self.current_stat.clone());
-                } else {
-                    let mut max = self.global_heap.peek_mut().unwrap();
-                    if hash < *max {
-                        *max = hash;
-                        self.hashes.insert(hash, self.current_stat.clone());
-                        self.hashes.remove(&max);
-                    }
+                    self.hashes.remove(&max);
                 }
             }
         }