fix(sync/singleflight): api enhance

Author: morlay

sync/singleflight/singleflight.go

@@ -69,7 +69,7 @@ type call[V any] struct {
 }
 
 type Group[K comparable] struct {
-	g Group2[K, struct{}]
+	g GroupValue[K, struct{}]
 }
 
 func (g *Group[K]) Do(key K, fn func() error) (error, bool) {
@@ -79,13 +79,19 @@ func (g *Group[K]) Do(key K, fn func() error) (error, bool) {
 	return err, shared
 }
 
+func (g *Group[K]) DoChan(key K, fn func() error) <-chan Result[struct{}] {
+	return g.g.DoChan(key, func() (struct{}, error) {
+		return struct{}{}, fn()
+	})
+}
+
 func (g *Group[K]) Forget(key K) {
 	g.g.Forget(key)
 }
 
-// Group2 represents a class of work and forms a namespace in
+// GroupValue represents a class of work and forms a namespace in
 // which units of work can be executed with duplicate suppression.
-type Group2[K comparable, V any] struct {
+type GroupValue[K comparable, V any] struct {
 	mu sync.Mutex     // protects m
 	m  map[K]*call[V] // lazily initialized
 }
@@ -103,7 +109,7 @@ type Result[V any] struct {
 // time. If a duplicate comes in, the duplicate caller waits for the
 // original to complete and receives the same results.
 // The return value shared indicates whether v was given to multiple callers.
-func (g *Group2[K, V]) Do(key K, fn func() (V, error)) (v V, err error, shared bool) {
+func (g *GroupValue[K, V]) Do(key K, fn func() (V, error)) (v V, err error, shared bool) {
 	g.mu.Lock()
 	if g.m == nil {
 		g.m = make(map[K]*call[V])
@@ -133,7 +139,7 @@ func (g *Group2[K, V]) Do(key K, fn func() (V, error)) (v V, err error, shared b
 // results when they are ready.
 //
 // The returned channel will not be closed.
-func (g *Group2[K, V]) DoChan(key K, fn func() (V, error)) <-chan Result[V] {
+func (g *GroupValue[K, V]) DoChan(key K, fn func() (V, error)) <-chan Result[V] {
 	ch := make(chan Result[V], 1)
 	g.mu.Lock()
 	if g.m == nil {
@@ -156,7 +162,7 @@ func (g *Group2[K, V]) DoChan(key K, fn func() (V, error)) <-chan Result[V] {
 }
 
 // doCall handles the single call for a key.
-func (g *Group2[K, V]) doCall(c *call[V], key K, fn func() (V, error)) {
+func (g *GroupValue[K, V]) doCall(c *call[V], key K, fn func() (V, error)) {
 	normalReturn := false
 	recovered := false
 
@@ -222,8 +228,12 @@ func (g *Group2[K, V]) doCall(c *call[V], key K, fn func() (V, error)) {
 // Forget tells the singleflight to forget about a key.  Future calls
 // to Do for this key will call the function rather than waiting for
 // an earlier call to complete.
-func (g *Group2[K, V]) Forget(key K) {
+func (g *GroupValue[K, V]) Forget(key K) {
 	g.mu.Lock()
 	delete(g.m, key)
 	g.mu.Unlock()
 }
+
+// Group2
+// Deprecated use GroupValue instead
+type Group2[K comparable, V any] = GroupValue[K, V]

sync/singleflight/singleflight_test.go

@@ -53,7 +53,7 @@ func TestPanicErrorUnwrap(t *testing.T) {
 
 			var recovered interface{}
 
-			group := &Group2[string, string]{}
+			group := &GroupValue[string, string]{}
 
 			func() {
 				defer func() {
@@ -83,7 +83,7 @@ func TestPanicErrorUnwrap(t *testing.T) {
 }
 
 func TestDo(t *testing.T) {
-	var g Group2[string, string]
+	var g GroupValue[string, string]
 	v, err, _ := g.Do("key", func() (string, error) {
 		return "bar", nil
 	})
@@ -96,7 +96,7 @@ func TestDo(t *testing.T) {
 }
 
 func TestDoErr(t *testing.T) {
-	var g Group2[string, string]
+	var g GroupValue[string, string]
 	someErr := errors.New("Some error")
 	v, err, _ := g.Do("key", func() (string, error) {
 		return "", someErr
@@ -110,7 +110,7 @@ func TestDoErr(t *testing.T) {
 }
 
 func TestDoDupSuppress(t *testing.T) {
-	var g Group2[string, string]
+	var g GroupValue[string, string]
 	var wg1, wg2 sync.WaitGroup
 	c := make(chan string, 1)
 	var calls int32
@@ -158,7 +158,7 @@ func TestDoDupSuppress(t *testing.T) {
 // Test that singleflight behaves correctly after Forget called.
 // See https://github.com/golang/go/issues/31420
 func TestForget(t *testing.T) {
-	var g Group2[string, int]
+	var g GroupValue[string, int]
 
 	var (
 		firstStarted  = make(chan struct{})
@@ -199,7 +199,7 @@ func TestForget(t *testing.T) {
 }
 
 func TestDoChan(t *testing.T) {
-	var g Group2[string, string]
+	var g GroupValue[string, string]
 	ch := g.DoChan("key", func() (string, error) {
 		return "bar", nil
 	})
@@ -218,7 +218,7 @@ func TestDoChan(t *testing.T) {
 // Test singleflight behaves correctly after Do panic.
 // See https://github.com/golang/go/issues/41133
 func TestPanicDo(t *testing.T) {
-	var g Group2[string, string]
+	var g GroupValue[string, string]
 	fn := func() (string, error) {
 		panic("invalid memory address or nil pointer dereference")
 	}
@@ -255,7 +255,7 @@ func TestPanicDo(t *testing.T) {
 }
 
 func TestGoexitDo(t *testing.T) {
-	var g Group2[string, string]
+	var g GroupValue[string, string]
 	fn := func() (string, error) {
 		runtime.Goexit()
 		return "", nil
@@ -309,7 +309,7 @@ func TestPanicDoChan(t *testing.T) {
 			recover()
 		}()
 
-		g := new(Group2[string, string])
+		g := new(GroupValue[string, string])
 		ch := g.DoChan("", func() (string, error) {
 			panic("Panicking in DoChan")
 		})
@@ -346,7 +346,7 @@ func TestPanicDoSharedByDoChan(t *testing.T) {
 		blocked := make(chan struct{})
 		unblock := make(chan struct{})
 
-		g := new(Group2[string, string])
+		g := new(GroupValue[string, string])
 		go func() {
 			defer func() {
 				recover()
@@ -392,7 +392,7 @@ func TestPanicDoSharedByDoChan(t *testing.T) {
 }
 
 func ExampleGroup() {
-	g := new(Group2[string, string])
+	g := new(GroupValue[string, string])
 
 	block := make(chan struct{})
 	res1c := g.DoChan("key", func() (string, error) {