How would you modify this version of wordcount for So ?

[serge-hulne]

I suppose you just would have to implement a scanner and a sort routine (quicksort?).

package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"sort"
)

func main() {

	var counts = make(map[string]float64)
	//var countTotal float64

	file, err := os.Open(os.Args[1])
	if err != nil {
		log.Fatal(err)
	}

	scanner := bufio.NewScanner(file)
	scanner.Split(bufio.ScanWords)
	for scanner.Scan() {
		counts[scanner.Text()] += 1.0
		//countTotal += 1.0
	}

	var words = make([]string, 0, len(counts))
	for word := range counts {
		words = append(words, word)
	}

	sort.SliceStable(words, func(i, j int) bool {
		return counts[words[i]] > counts[words[j]]
	})

	cpt := 0
	for _, word := range words {
		if cpt < 9 {
			//fmt.Println(word, ": ", counts[word]/countTotal)
			fmt.Println(word, ": ", counts[word])
			cpt++
		}
	}

}

[nalgeon]

So is currently missing the bufio package. Sorting is already implemented in the slices package.

You can see the packages planned for v0.1.0 in the roadmap. Stay tuned!

[serge-hulne]

Thanks!

[serge-hulne]

Here is my attempt to rewrite Wordcount in So:

package main

import (
	"solod.dev/so/bufio"
	"solod.dev/so/c"
	"solod.dev/so/fmt"
	"solod.dev/so/maps"
	"solod.dev/so/mem"
	"solod.dev/so/os"
	"solod.dev/so/slices"
	"solod.dev/so/strings"
)

// WordCount pairs a word with its frequency count.
type WordCount struct {
	word  string
	count float64
}

// wordCountCmp compares two WordCount elements by count, descending.
// a and b are void* pointers to WordCount elements in the slice being sorted.
func wordCountCmp(a, b any) int {
	va := *c.PtrAs[WordCount](a)
	vb := *c.PtrAs[WordCount](b)
	if va.count > vb.count {
		return -1
	}
	if va.count < vb.count {
		return 1
	}
	return 0
}

func main() {
	counts := maps.New[string, float64](nil, 0)
	defer counts.Free()

	file, err := os.Open(os.Args[1])
	if err != nil {
		panic(err)
	}
	defer file.Close()

	scanner := bufio.NewScanner(nil, &file)
	defer scanner.Free()
	scanner.Split(bufio.ScanWords)

	for scanner.Scan() {
		word := scanner.Text()
		if !counts.Has(word) {
			// Clone the word so the key outlives the scanner buffer.
			cloned := strings.Clone(nil, word)
			counts.Set(cloned, 1.0)
		} else {
			cnt := counts.Get(word)
			counts.Set(word, cnt+1.0)
		}
	}

	n := counts.Len()
	wcs := slices.Make[WordCount](nil, n)

	idx := 0
	it := counts.Iter()
	for it.Next() {
		wcs[idx] = WordCount{word: it.Key(), count: it.Value()}
		idx++
	}
	slices.SortStableFunc[WordCount](wcs, wordCountCmp)

	cpt := 0
	for _, wc := range wcs {
		if cpt < 9 {
			fmt.Printf("%s :  %g\n", wc.word, wc.count)
			cpt++
		}
	}

	// Free heap resources acquired during scanning.
	for i := range wcs {
		mem.FreeString(nil, wcs[i].word)
	}
	slices.Free[WordCount](nil, wcs)
}

[nalgeon]

Very nice, thank you!

Just a small note — you can use a regular type assertion instead of c.PtrAs:

func wordCountCmp(a, b any) int {
	va := a.(*WordCount)
	vb := b.(*WordCount)
	if va.count > vb.count {
		return -1
	}
	if va.count < vb.count {
		return 1
	}
	return 0
}

[serge-hulne]

Nice. PS: Feel free to use my code in your examples.

[nalgeon]

Thanks, will do!