Make key type generic with Group[K comparable, T any]

Allow any comparable type as key, not just strings.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: MagicalTux

README.md

@@ -20,7 +20,7 @@ import (
     "github.com/KarpelesLab/unison"
 )
 
-var group unison.Group[string]
+var group unison.Group[string, string]
 
 func main() {
     result, err := group.Do("my-key", func() (string, error) {
@@ -44,7 +44,7 @@ func main() {
 ## Example: Caching Expensive Operations
 
 ```go
-var userLoader unison.Group[*User]
+var userLoader unison.Group[string, *User]
 
 func GetUser(id string) (*User, error) {
     return userLoader.Do(id, func() (*User, error) {
@@ -58,7 +58,7 @@ func GetUser(id string) (*User, error) {
 ## Example: Preventing Thundering Herd
 
 ```go
-var cacheRefresh unison.Group[[]Product]
+var cacheRefresh unison.Group[string, []Product]
 
 func GetProducts() ([]Product, error) {
     return cacheRefresh.Do("products", func() ([]Product, error) {
@@ -72,7 +72,7 @@ func GetProducts() ([]Product, error) {
 ## Example: Time-Based Caching with DoUntil
 
 ```go
-var configLoader unison.Group[*Config]
+var configLoader unison.Group[string, *Config]
 
 func GetConfig() (*Config, error) {
     return configLoader.DoUntil("config", 5*time.Minute, func() (*Config, error) {
@@ -85,19 +85,20 @@ func GetConfig() (*Config, error) {
 
 ## API
 
-### `Group[T any]`
+### `Group[K comparable, T any]`
 
-A generic type that manages in-flight function calls. Zero-value is ready to use.
+A generic type that manages in-flight function calls. `K` is the key type (must be comparable), `T` is the result type. Zero-value is ready to use.
 
 ```go
-var g unison.Group[string]
+var g unison.Group[string, string]    // string keys, string values
+var g unison.Group[int, *User]        // int keys, *User values
 ```
 
-### `(*Group[T]) Do(key string, fn func() (T, error)) (T, error)`
+### `(*Group[K, T]) Do(key K, fn func() (T, error)) (T, error)`
 
 Executes `fn` for the given `key`, ensuring only one execution is in-flight at a time per key. Concurrent callers with the same key wait for the first caller's result. Once complete, subsequent calls trigger a new execution.
 
-### `(*Group[T]) DoUntil(key string, dur time.Duration, fn func() (T, error)) (T, error)`
+### `(*Group[K, T]) DoUntil(key K, dur time.Duration, fn func() (T, error)) (T, error)`
 
 Like `Do`, but caches the result for the specified duration. Subsequent calls within the cache window return the cached result without executing `fn` again. After expiration, the next call triggers a new execution.
 

unison.go

@@ -16,19 +16,19 @@ type call[T any] struct {
 
 // Group represents a class of work and forms a namespace in which
 // units of work can be executed with duplicate suppression.
-type Group[T any] struct {
+type Group[K comparable, T any] struct {
 	mu sync.Mutex
-	m  map[string]*call[T]
+	m  map[K]*call[T]
 }
 
 // Do executes and returns the results of the given function, making
 // sure that only one execution is in-flight for a given key at a time.
 // If a duplicate comes in, the duplicate caller waits for the original
 // to complete and receives the same results.
-func (g *Group[T]) Do(key string, fn func() (T, error)) (T, error) {
+func (g *Group[K, T]) Do(key K, fn func() (T, error)) (T, error) {
 	g.mu.Lock()
 	if g.m == nil {
-		g.m = make(map[string]*call[T])
+		g.m = make(map[K]*call[T])
 	}
 
 	if c, ok := g.m[key]; ok {
@@ -57,10 +57,10 @@ func (g *Group[T]) Do(key string, fn func() (T, error)) (T, error) {
 // DoUntil is like Do but caches the result for the specified duration.
 // Subsequent calls within the cache window return the cached result without
 // executing the function again.
-func (g *Group[T]) DoUntil(key string, dur time.Duration, fn func() (T, error)) (T, error) {
+func (g *Group[K, T]) DoUntil(key K, dur time.Duration, fn func() (T, error)) (T, error) {
 	g.mu.Lock()
 	if g.m == nil {
-		g.m = make(map[string]*call[T])
+		g.m = make(map[K]*call[T])
 	}
 
 	if c, ok := g.m[key]; ok {

unison_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 func TestDo(t *testing.T) {
-	var g Group[string]
+	var g Group[string, string]
 	v, err := g.Do("key", func() (string, error) {
 		return "bar", nil
 	})
@@ -22,7 +22,7 @@ func TestDo(t *testing.T) {
 }
 
 func TestDoErr(t *testing.T) {
-	var g Group[string]
+	var g Group[string, string]
 	someErr := errors.New("some error")
 	v, err := g.Do("key", func() (string, error) {
 		return "", someErr
@@ -36,7 +36,7 @@ func TestDoErr(t *testing.T) {
 }
 
 func TestDoDupSuppress(t *testing.T) {
-	var g Group[string]
+	var g Group[string, string]
 	var calls atomic.Int32
 	var wg sync.WaitGroup
 
@@ -68,7 +68,7 @@ func TestDoDupSuppress(t *testing.T) {
 }
 
 func TestDoNewCallAfterComplete(t *testing.T) {
-	var g Group[int]
+	var g Group[string, int]
 	var calls atomic.Int32
 
 	fn := func() (int, error) {
@@ -90,7 +90,7 @@ func TestDoNewCallAfterComplete(t *testing.T) {
 }
 
 func TestDoDifferentKeys(t *testing.T) {
-	var g Group[string]
+	var g Group[string, string]
 	var calls atomic.Int32
 	var wg sync.WaitGroup
 
@@ -125,7 +125,7 @@ func TestDoDifferentKeys(t *testing.T) {
 }
 
 func TestDoUntil(t *testing.T) {
-	var g Group[string]
+	var g Group[string, string]
 	v, err := g.DoUntil("key", time.Second, func() (string, error) {
 		return "bar", nil
 	})
@@ -138,7 +138,7 @@ func TestDoUntil(t *testing.T) {
 }
 
 func TestDoUntilCached(t *testing.T) {
-	var g Group[int]
+	var g Group[string, int]
 	var calls atomic.Int32
 
 	fn := func() (int, error) {
@@ -158,7 +158,7 @@ func TestDoUntilCached(t *testing.T) {
 }
 
 func TestDoUntilExpired(t *testing.T) {
-	var g Group[int]
+	var g Group[string, int]
 	var calls atomic.Int32
 
 	fn := func() (int, error) {
@@ -181,7 +181,7 @@ func TestDoUntilExpired(t *testing.T) {
 }
 
 func TestDoUntilDupSuppress(t *testing.T) {
-	var g Group[string]
+	var g Group[string, string]
 	var calls atomic.Int32
 	var wg sync.WaitGroup
 
@@ -211,3 +211,23 @@ func TestDoUntilDupSuppress(t *testing.T) {
 		t.Errorf("number of calls = %d; want 1", got)
 	}
 }
+
+func TestDoIntKey(t *testing.T) {
+	var g Group[int, string]
+	var calls atomic.Int32
+
+	fn := func() (string, error) {
+		calls.Add(1)
+		return "value", nil
+	}
+
+	v1, _ := g.Do(123, fn)
+	v2, _ := g.Do(456, fn)
+
+	if v1 != "value" || v2 != "value" {
+		t.Errorf("values = %v, %v; want value, value", v1, v2)
+	}
+	if got := calls.Load(); got != 2 {
+		t.Errorf("number of calls = %d; want 2", got)
+	}
+}