run clippy lol

src/lib.rs

@@ -5,7 +5,7 @@ use std::sync::atomic::{AtomicUsize, Ordering};
 use fnv::FnvHashSet;
 
 fn is_valid_ascii_chr(c: u8) -> bool {
-    (c >= 32 && c <= 126) || c == 9 || c == 10 || c == 13
+    (32..=126).contains(&c) || c == 9 || c == 10 || c == 13
 }
 
 pub fn get_strings<T>(stream: &mut T, min_len: usize) -> std::io::Result<FnvHashSet<u32>>
@@ -78,6 +78,7 @@ where
     Ok(pointers)
 }
 
+#[derive(Default)]
 pub struct ComputeProgress {
     num_completed: AtomicUsize,
 }
@@ -85,9 +86,7 @@ pub struct ComputeProgress {
 impl ComputeProgress {
     #[inline]
     pub fn new() -> ComputeProgress {
-        ComputeProgress {
-            num_completed: AtomicUsize::new(0),
-        }
+        Default::default()
     }
 
     #[inline]
@@ -104,7 +103,7 @@ pub fn compute_matches(
     page_size: u32,
     progress: Option<&ComputeProgress>,
 ) -> BinaryHeap<(usize, u32)> {
-    if let Some(ref progress) = progress {
+    if let Some(progress) = progress {
         progress.num_completed.store(0, Ordering::Relaxed);
     }
     (start_addr..end_addr)
@@ -119,7 +118,7 @@ pub fn compute_matches(
                 0 => None,
                 ct => Some((ct, page)),
             };
-            if let Some(ref progress) = progress {
+            if let Some(progress) = progress {
                 progress.num_completed.fetch_add(1, Ordering::Relaxed);
             }
             res

src/main.rs

@@ -76,15 +76,17 @@ fn main() -> Result<()> {
     let total_pages = ((end - start) / (args.page_size as u64)) as usize;
     let chunk_size = (end - start) / (args.threads as u64);
 
-    let progress_counters: Vec<_> =
-        (0..args.threads).map(|_| lib::ComputeProgress::new()).collect();
+    let progress_counters: Vec<_> = (0..args.threads)
+        .map(|_| lib::ComputeProgress::new())
+        .collect();
 
     let mut thread_results = std::thread::scope(|s| {
         let ranges = (start..=end)
             .step_by(chunk_size as usize)
             .zip((start + chunk_size..=end).step_by(chunk_size as usize));
 
-        let tasks: Vec<_> = ranges.zip(progress_counters.iter())
+        let tasks: Vec<_> = ranges
+            .zip(progress_counters.iter())
             .map(|((start, end), counter)| {
                 let strings = &strings;
                 let pointers = &pointers;
@@ -108,11 +110,17 @@ fn main() -> Result<()> {
                     term.carriage_return().unwrap();
                     term.delete_line().unwrap();
 
-                    let completed_pages: usize =
-                        progress_counters.iter().map(|prg| prg.num_completed()).sum();
+                    let completed_pages: usize = progress_counters
+                        .iter()
+                        .map(|prg| prg.num_completed())
+                        .sum();
 
-                    eprint!("{} / {} ({}%)", completed_pages, total_pages,
-                        completed_pages * 100 / total_pages);
+                    eprint!(
+                        "{} / {} ({}%)",
+                        completed_pages,
+                        total_pages,
+                        completed_pages * 100 / total_pages
+                    );
                     std::io::stderr().flush().unwrap();
                 } else {
                     break;
@@ -140,7 +148,7 @@ fn main() -> Result<()> {
     } else {
         let mut results_buf = vec![];
         for _ in 0..args.max_matches {
-            results_buf.extend(thread_results.iter_mut().map(|res| res.pop()).flatten());
+            results_buf.extend(thread_results.iter_mut().filter_map(|res| res.pop()));
             results_buf.sort();
             match results_buf.pop() {
                 None => break,