Word count

// WordCount: how often does each word appear in a tongue twister?
//
// Counting is what a hash map is for. Each word is a key and its count the value: look the word
// up, add one, store it back. A word not seen before is simply absent, and `?? 0` turns that
// absence into a count of zero to add to.
//
// A hash map keeps no order, though, so printing it straight out would list the words however the
// hashing scattered them. Copying the finished counts into a `TreeMap` sorts them by word for
// free, because a tree map walks its keys in order.
//
// Two details make the words come out right. "How" and "how" should count as one word, so the
// text is first copied in lower case. And the map's keys are slices of that copy, not new strings:
// each word is a view of the bytes it occupies, which costs nothing to make.
import Allocator::{ Allocator, SystemAllocator };
import Collections::{ CollectionError, CompareSlice, EqualsSlice, HashMap, HashSlice, TreeMap };
import Io::{ Print, PrintLine };
import Text::{ StringBuilder, TextError };

func IsLetter(c: char8) -> bool {
    return c >= c8'a' && c <= c8'z';
}

// Adds the text to the builder with every capital letter A to Z made small, and the rest as it is.
func AppendLowercase(builder: &var StringBuilder, text: char8[..]) -> ! TextError {
    for c in text {
        if c >= c8'A' && c <= c8'Z' {
            builder.AppendAscii(c - c8'A' + c8'a')?;
        } else {
            builder.AppendAscii(c)?;
        }
    }
}

func Main() -> ! (CollectionError | TextError) {
    var system = SystemAllocator();
    let allocator: Allocator = system;

    let twister = [
        "How much wood would a woodchuck chuck",
        "if a woodchuck could chuck wood?",
        "He would chuck, he would, as much as he could,",
        "and chuck as much wood as a woodchuck would",
        "if a woodchuck could chuck wood."
    ];
    // One lower-case copy of the whole text, with a space where each line ended. Every key in the
    // maps below is a view into it, so nothing is appended to it after this loop.
    var lower = StringBuilder(allocator);
    for line in twister {
        AppendLowercase(lower, line)?;
        lower.AppendAscii(c8' ')?;
    }
    let text = lower.Bytes();

    // Walk the text once. `start` marks where the current word began; a byte that is not a
    // letter ends the word, and the slice between them is the key.
    var counts = HashMap<char8[..], int32>(allocator, HashSlice, EqualsSlice);
    var words = 0;
    var start: uint = 0;
    for i in 0..=text.length {
        let inWord = i < text.length && IsLetter(text[i]);
        if inWord {
            continue;
        }
        if i > start {
            let word = text[start..i];
            counts.Insert(word, (counts.Get(word) ?? 0) + 1)?;
            words += 1;
        }
        start = i + 1;
    }
    PrintLine("{} words, {} different", words, counts.Length());
    PrintLine();

    // Same entries, now in alphabetical order.
    var sorted = TreeMap<char8[..], int32>(allocator, CompareSlice);
    for entry in counts {
        sorted.Insert(entry.key, entry.value)?;
    }

    var top: char8[..] = "";
    var topCount = 0;
    for entry in sorted {
        Print("{:10} {:2}  ", entry.key, entry.value);
        for i in 0..entry.value {
            Print("*");
        }
        PrintLine();
        // Strictly greater, so a tie goes to the word earlier in the alphabet.
        if entry.value > topCount {
            top = entry.key;
            topCount = entry.value;
        }
    }
    PrintLine();
    PrintLine("the favourite word is \"{}\", {} times", top, topCount);
}