Rust 실습 — wordfreq 2판: 라이브러리·반복자·스레드·테스트

use std::collections::HashMap;

pub type Counts = HashMap<String, usize>;

pub fn count_words(text: &str) -> Counts {
    let mut counts = Counts::new();
    let words = text
        .split_whitespace()
        .map(|raw| raw.trim_matches(['.', ',', '!', '?', '"']).to_lowercase())
        .filter(|word| !word.is_empty());
    for word in words {
        *counts.entry(word).or_insert(0) += 1;
    }
    counts
}

pub fn merge(total: &mut Counts, part: Counts) {
    for (word, n) in part {
        *total.entry(word).or_insert(0) += n;
    }
}

pub fn top(counts: Counts, n: usize) -> Vec<(String, usize)> {
    let mut pairs: Vec<(String, usize)> = counts.into_iter().collect();
    pairs.sort_by(|a, b| b.1.cmp(&a.1).then(a.0.cmp(&b.0)));
    pairs.truncate(n);
    pairs
}

use std::{env, fs, process, thread};
use wordfreq::{Counts, count_words, merge, top};

fn main() {
    let paths: Vec<String> = env::args().skip(1).collect();
    if paths.is_empty() {
        eprintln!("usage: wordfreq <file>...");
        process::exit(2);
    }

    let handles: Vec<_> = paths
        .into_iter()
        .map(|path| {
            thread::spawn(move || {
                fs::read_to_string(&path)
                    .map(|text| count_words(&text))
                    .map_err(|e| format!("cannot read {path}: {e}"))
            })
        })
        .collect();

    let mut total = Counts::new();
    for handle in handles {
        match handle.join().unwrap() {
            Ok(counts) => merge(&mut total, counts),
            Err(message) => {
                eprintln!("{message}");
                process::exit(1);
            }
        }
    }

    for (word, n) in top(total, 10) {
        println!("{n:>3} {word}");
    }
}

   Compiling wordfreq v0.2.0 (~/projects/wordfreq)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.86s
     Running `target/debug/wordfreq a.txt b.txt`
 15 the
  7 is
  6 code
  5 and
  4 it
  3 a
  3 build
  3 compiler
  3 fix
  3 run

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn ignores_case_and_punctuation() {
        let counts = count_words("Rust, rust! RUST.");
        assert_eq!(counts.get("rust"), Some(&3));
    }

    #[test]
    fn merge_adds_counts() {
        let mut total = count_words("a b");
        merge(&mut total, count_words("b c"));
        assert_eq!(total.get("b"), Some(&2));
        assert_eq!(total.len(), 3);
    }

    #[test]
    fn top_breaks_ties_alphabetically() {
        let result = top(count_words("b a c a b"), 2);
        assert_eq!(result, vec![("a".to_string(), 2), ("b".to_string(), 2)]);
    }

    #[test]
    fn empty_text_has_no_words() {
        assert!(count_words("  ... !! ").is_empty());
    }
}