manually clean code with clippy

src/agg/mod.rs

@@ -14,7 +14,7 @@ pub trait Aggregator {
     fn aggregate(&self, taxons: &HashMap<TaxonId, f32>) -> Result<TaxonId>;
 
     /// Aggregates a list of taxons into a resulting taxon id.
-    fn counting_aggregate(&self, taxons: &Vec<TaxonId>) -> Result<TaxonId> {
+    fn counting_aggregate(&self, taxons: &[TaxonId]) -> Result<TaxonId> {
         let taxons = taxons.iter().map(|&t| (t, 1.0));
         self.aggregate(&count(taxons))
     }

src/commands/buildindex.rs

@@ -6,6 +6,7 @@ use crate::errors;
 
 #[derive(Debug, StructOpt)]
 #[structopt(verbatim_doc_comment)]
+#[allow(clippy::tabs_in_doc_comments)]
 /// Builds an index mapping short strings to taxon IDs
 ///
 /// The `umgap buildindex` command takes tab-separated strings and taxon IDs, and creates a

src/commands/joinkmers.rs

@@ -13,6 +13,7 @@ use crate::tree;
 
 #[derive(Debug, StructOpt)]
 #[structopt(verbatim_doc_comment)]
+#[allow(clippy::tabs_in_doc_comments)]
 /// Aggregates a TSV stream of peptides and taxon IDs
 ///
 /// The `umgap joinkmers` command takes tab-separated peptides and taxon IDs, aggregates the

src/commands/printindex.rs

@@ -9,6 +9,7 @@ use crate::errors;
 
 #[derive(Debug, StructOpt)]
 #[structopt(verbatim_doc_comment)]
+#[allow(clippy::tabs_in_doc_comments)]
 /// Prints the key/value pairs in an index
 ///
 /// Outputs the string keys and taxon ID values in TSV format, mostly for debugging purposes.

src/commands/prot2kmer2lca.rs

@@ -186,7 +186,7 @@ where
             output_mutex
                 .lock()
                 .unwrap()
-                .write(chunk_output.as_bytes())?;
+                .write_all(chunk_output.as_bytes())?;
             Ok(())
         })
         .collect()

src/commands/splitkmers.rs

@@ -68,10 +68,12 @@ pub fn splitkmers(args: SplitKmers) -> errors::Result<()> {
             continue;
         }
         for kmer in sequence.as_bytes().windows(args.length) {
-            if byte.is_none() {
+            if let Some(&b) = byte {
+                if b == kmer[0] {
+                    writer.serialize((String::from_utf8_lossy(&kmer[1..]), tid))?;
+                }
+            } else {
                 writer.serialize((String::from_utf8_lossy(kmer), tid))?;
-            } else if *byte.unwrap() == kmer[0] {
-                writer.serialize((String::from_utf8_lossy(&kmer[1..]), tid))?;
             }
         }
     }

src/commands/taxa2agg.rs

@@ -139,15 +139,15 @@ pub fn taxa2agg(args: TaxaToAgg) -> errors::Result<()> {
     };
     let aggregator = aggregator?;
 
-    fn with_score(pair: &String) -> errors::Result<(TaxonId, f32)> {
+    fn with_score(pair: &str) -> errors::Result<(TaxonId, f32)> {
         let split = pair.split('=').collect::<Vec<_>>();
         if split.len() != 2 {
             return Err("Taxon without score".into());
         }
         Ok((split[0].parse::<TaxonId>()?, split[1].parse::<f32>()?))
     }
 
-    fn not_scored(tid: &String) -> errors::Result<(TaxonId, f32)> {
+    fn not_scored(tid: &str) -> errors::Result<(TaxonId, f32)> {
         Ok((tid.parse::<TaxonId>()?, 1.0))
     }
 
@@ -162,7 +162,7 @@ pub fn taxa2agg(args: TaxaToAgg) -> errors::Result<()> {
         let taxons = record
             .sequence
             .iter()
-            .map(parser)
+            .map(|s| parser(s))
             .collect::<errors::Result<Vec<(TaxonId, f32)>>>()?;
 
         // Create a frequency table of taxons for this read (taking into account the lower bound)

src/commands/taxa2freq.rs

@@ -152,20 +152,17 @@ pub fn taxa2freq(args: TaxaToFreq) -> errors::Result<()> {
 }
 
 fn count_file<T: BufRead>(
-    snapping: &Vec<Option<taxon::TaxonId>>,
+    snapping: &[Option<taxon::TaxonId>],
     counts: &mut HashMap<taxon::TaxonId, Vec<usize>>,
     index: usize,
     numfiles: usize,
     file: T,
 ) -> errors::Result<()> {
     for line in file.lines() {
-        match line?.parse::<taxon::TaxonId>() {
-            Ok(taxon) => {
-                counts
-                    .entry(snapping[taxon].unwrap_or(0))
-                    .or_insert(vec![0; numfiles])[index] += 1
-            }
-            Err(_) => (),
+        if let Ok(taxon) = line?.parse::<taxon::TaxonId>() {
+            counts
+                .entry(snapping[taxon].unwrap_or(0))
+                .or_insert_with(|| vec![0; numfiles])[index] += 1
         }
     }
     Ok(())

src/commands/taxonomy.rs

@@ -12,6 +12,7 @@ use crate::taxon;
 #[rustfmt::skip]
 #[derive(Debug, StructOpt)]
 #[structopt(verbatim_doc_comment)]
+#[allow(clippy::tabs_in_doc_comments)]
 /// Includes info in a stream of taxon IDs
 ///
 /// The `umgap taxonomy` command takes one or more taxon IDs as input, searches for them in a

src/commands/uniq.rs

@@ -59,9 +59,12 @@ pub fn uniq(args: Uniq) -> errors::Result<()> {
     for record in fasta::Reader::new(io::stdin(), false).records() {
         let mut record = record?;
         if let Some(ref delimiter) = args.delimiter {
-            record
-                .header
-                .truncate(record.header.find(delimiter).unwrap_or(record.header.len()));
+            record.header.truncate(
+                record
+                    .header
+                    .find(delimiter)
+                    .unwrap_or_else(|| record.header.len()),
+            );
         }
         if let Some(ref mut rec) = last {
             if rec.header == record.header {

src/dna/mod.rs

@@ -22,11 +22,11 @@ impl Nucleotide {
     /// Complement of the given nucleotide.
     pub fn complement(&self) -> Self {
         match self {
-            &A => T,
-            &C => G,
-            &G => C,
-            &T => A,
-            &N => N,
+            A => T,
+            C => G,
+            G => C,
+            T => A,
+            N => N,
         }
     }
 }
@@ -43,9 +43,9 @@ impl From<u8> for Nucleotide {
     }
 }
 
-impl Into<u8> for Nucleotide {
-    fn into(self) -> u8 {
-        match self {
+impl From<Nucleotide> for u8 {
+    fn from(n: Nucleotide) -> u8 {
+        match n {
             A => b'A',
             C => b'C',
             G => b'G',
@@ -89,7 +89,7 @@ impl<'a> From<&'a Vec<String>> for Strand {
 
 impl Strand {
     /// A reading frame of this strand, 1-indexed.
-    pub fn frame<'a>(&'a self, start: usize) -> Frame<'a> {
+    pub fn frame(&self, start: usize) -> Frame<'_> {
         Frame(if self.0.len() > start - 1 {
             &self.0[start - 1..]
         } else {

src/dna/translation.rs

@@ -180,7 +180,7 @@ impl str::FromStr for &'static TranslationTable {
         let id = s.parse::<usize>()?;
         TABLES[id - 1]
             .as_ref()
-            .ok_or(ErrorKind::UnknownTable(id).into())
+            .ok_or_else(|| ErrorKind::UnknownTable(id).into())
     }
 }
 

src/io/fasta.rs

@@ -31,7 +31,7 @@ impl<R: Read> Reader<R> {
         let lines = BufReader::with_capacity(BUFFER_SIZE, reader)
             .lines()
             .peekable();
-        Reader { unwrap, lines }
+        Reader { lines, unwrap }
     }
 
     /// Reads the next record from the FASTA file.
@@ -166,7 +166,7 @@ impl<'a, W: Write> Writer<'a, W> {
         let sequence = record.sequence.join(self.separator);
         if !self.wrap {
             self.buffer.write_all(&[b'\n'])?;
-            self.buffer.write(sequence.as_bytes())?;
+            self.buffer.write_all(sequence.as_bytes())?;
         } else {
             for subseq in sequence.as_bytes().chunks(FASTA_WIDTH) {
                 self.buffer.write_all(&[b'\n'])?;

src/rmq/lca.rs

@@ -49,7 +49,7 @@ impl LCACalculator {
     fn first_occurence(&self, taxon_id: TaxonId) -> taxon::Result<usize> {
         self.first_occurences
             .get(&taxon_id)
-            .ok_or(taxon::ErrorKind::UnknownTaxon(taxon_id).into())
+            .ok_or_else(|| taxon::ErrorKind::UnknownTaxon(taxon_id).into())
             .map(|t| *t)
     }
 }