implement basic autocomplete package

autocomplete/autocomplete.go

@@ -0,0 +1,113 @@
+package autocomplete
+
+import (
+	"slices"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+// Set is an autocomplete set.
+type Set struct {
+	mask []uint64
+	keys [][]string
+	vals [][]string
+}
+
+var (
+	test [2]uint64
+	idxs [256]byte
+)
+
+const careset = " 0123456789abcdefghijklmnopqrstuvwxyz.!'"
+
+// Certify the size of careset at compile time.
+// It must be no larger than 64.
+var _ [0]struct{} = [len(careset) - 40]struct{}{}
+
+func init() {
+	// Construct the test and idxs maps.
+	for i, c := range []byte(careset) {
+		if c < 64 {
+			test[0] |= 1 << c
+		} else {
+			test[1] |= 1 << (c - 64)
+		}
+		idxs[c] = byte(i)
+	}
+}
+
+func normalize(s string) string {
+	s = strings.Map(func(c rune) rune {
+		c = unicode.ToLower(c)
+		// TODO(zeph): map latin letters with diacritics to their not-diacritic
+		// characters; e.g. 2* pasta's unique Corazón ☆ Ardiente should have
+		// ó mapped to o. for now, we just special-case it.
+		if c == 'ó' {
+			c = 'o'
+		}
+		return c
+	}, s)
+	return s
+}
+
+func filter(s string) (r uint64) {
+	for _, c := range s {
+		if c > 0x7f {
+			// Skip non-ASCII characters.
+			continue
+		}
+		if test[byte(c)/64]>>(byte(c)%64)&1 == 0 {
+			// Not in the care set.
+			continue
+		}
+		r |= 1 << idxs[byte(c)]
+	}
+	return r
+}
+
+// Add associates a value with a key in the autocomplete set.
+// The behavior is undefined if the key already has a value.
+func (s *Set) Add(key, val string) {
+	key = normalize(key)
+	m := filter(key)
+	i, ok := slices.BinarySearch(s.mask, m)
+	if !ok {
+		s.mask = slices.Insert(s.mask, i, m)
+		s.keys = slices.Insert(s.keys, i, nil)
+		s.vals = slices.Insert(s.vals, i, nil)
+	}
+	j, _ := slices.BinarySearch(s.keys[i], key)
+	s.keys[i] = slices.Insert(s.keys[i], j, key)
+	s.vals[i] = slices.Insert(s.vals[i], j, val)
+}
+
+// Find appends to r all values in the set with keys that key matches.
+func (s *Set) Find(r []string, key string) []string {
+	key = normalize(key)
+	m := filter(key)
+	for i, v := range s.mask {
+		if m&v != m {
+			continue
+		}
+		for j, k := range s.keys[i] {
+			if inorder(key, k) {
+				r = append(r, s.vals[i][j])
+			}
+		}
+	}
+	return r
+}
+
+// inorder checks whether each character in a appears in the same relative order in b.
+func inorder(a, b string) bool {
+	for _, c := range a {
+		k := strings.IndexRune(b, c)
+		if k < 0 {
+			return false
+		}
+		_, l := utf8.DecodeRuneInString(b[k:])
+		b = b[k+l:]
+	}
+	return true
+}