Word Counter Pro 📊

trim_matches with a closure strips unwanted characters from both ends:

fn clean_word(raw: &str) -> String {
    raw.trim_matches(|c: char| !c.is_alphanumeric()).to_lowercase()
}

Note it can return an empty string (for input like ---), so skip empties when counting. Why only trim the ends? So don't keeps its apostrophe. Text is sneaky; Lesson 18 warned you.

The entry pattern from Lesson 10, at the center of the whole tool:

fn count_words(text: &str) -> HashMap<String, u32> {
    let mut counts = HashMap::new();
    for raw in text.split_whitespace() {
        let word = clean_word(raw);
        if !word.is_empty() {
            *counts.entry(word).or_insert(0) += 1;
        }
    }
    counts
}

Keeping this a pure function (text in, map out) is what makes it testable without any files.

A HashMap has no order, so convert to a Vec of pairs, sort, truncate:

fn top_words(counts: &HashMap<String, u32>, n: usize) -> Vec<(String, u32)> {
    let mut pairs: Vec<(String, u32)> = counts
        .iter()
        .map(|(w, c)| (w.clone(), *c))
        .collect();
    pairs.sort_by(|a, b| b.1.cmp(&a.1).then(a.0.cmp(&b.0)));
    pairs.truncate(n);
    pairs
}

Format specifiers pad for you: {count:>6} right-aligns the count in six columns. That is the whole trick behind pretty tables:

for (word, count) in top_words(&counts, top_n) {
    println!("  {count:>6}  {word}");
}

use std::collections::HashMap;
use std::env;
use std::fs;
use std::process;

fn clean_word(raw: &str) -> String {
    raw.trim_matches(|c: char| !c.is_alphanumeric()).to_lowercase()
}

fn count_words(text: &str) -> HashMap<String, u32> {
    let mut counts = HashMap::new();
    for raw in text.split_whitespace() {
        let word = clean_word(raw);
        if !word.is_empty() {
            *counts.entry(word).or_insert(0) += 1;
        }
    }
    counts
}

fn top_words(counts: &HashMap<String, u32>, n: usize) -> Vec<(String, u32)> {
    let mut pairs: Vec<(String, u32)> = counts
        .iter()
        .map(|(w, c)| (w.clone(), *c))
        .collect();
    // most frequent first; ties broken alphabetically
    pairs.sort_by(|a, b| b.1.cmp(&a.1).then(a.0.cmp(&b.0)));
    pairs.truncate(n);
    pairs
}

fn main() {
    let args: Vec<String> = env::args().collect();
    let Some(path) = args.get(1) else {
        eprintln!("usage: wordcount <file> [top_n]");
        process::exit(1);
    };
    let top_n: usize = args.get(2).and_then(|s| s.parse().ok()).unwrap_or(10);

    let text = match fs::read_to_string(path) {
        Ok(t) => t,
        Err(e) => {
            eprintln!("could not read {path}: {e}");
            process::exit(1);
        }
    };

    let counts = count_words(&text);
    let total_words: u32 = counts.values().sum();

    println!("📄 {path}");
    println!("  lines:        {}", text.lines().count());
    println!("  words:        {total_words}");
    println!("  characters:   {}", text.chars().count());
    println!("  unique words: {}", counts.len());
    println!("\n  top {top_n} words:");
    for (word, count) in top_words(&counts, top_n) {
        println!("  {count:>6}  {word}");
    }
}

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

    #[test]
    fn cleans_punctuation_and_case() {
        assert_eq!(clean_word("Hello,"), "hello");
        assert_eq!(clean_word("(rust)"), "rust");
        assert_eq!(clean_word("---"), "");
    }

    #[test]
    fn counts_are_case_insensitive() {
        let counts = count_words("Crab crab CRAB! ocean");
        assert_eq!(counts["crab"], 3);
        assert_eq!(counts["ocean"], 1);
    }

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

Run it on something fun: your own main.rs, a downloaded book from Project Gutenberg, or this course's launch post. Note .chars().count() instead of .len() for the character count: Lesson 18 paying rent already.