Modernize examples

Author: janos

README.md

@@ -38,43 +38,43 @@ Here's a simple example of how to protect a function from concurrent calls.
 package main
 
 import (
-	"context"
-	"fmt"
-	"sync"
-	"time"
+    "context"
+    "fmt"
+    "sync"
+    "time"
 
-	"resenje.org/singleflight"
+    "resenje.org/singleflight"
 )
 
 func main() {
-	var g singleflight.Group[string, string]
-	var wg sync.WaitGroup
-	n := 5
-
-	// Make 5 concurrent calls for the same key.
-	wg.Add(n)
-	for i := 0; i < n; i++ {
-		go func(i int) {
-			defer wg.Done()
-
-			// The function will only be executed for the first call.
-			// All other calls will wait and receive the same result.
-			v, shared, err := g.Do(context.Background(), "user-profile", func(ctx context.Context) (string, error) {
-				fmt.Println("Fetching user profile from database...")
-				time.Sleep(100 * time.Millisecond) // Simulate slow DB query
-				return "User data for John Doe", nil
-			})
-
-			if err != nil {
-				fmt.Printf("Goroutine %d: encountered an error: %v\n", i, err)
-				return
-			}
-
-			fmt.Printf("Goroutine %d: got result '%s' (shared: %t)\n", i, v, shared)
-		}(i)
-	}
-
-	wg.Wait()
+    var g singleflight.Group[string, string]
+    var wg sync.WaitGroup
+    n := 5
+
+    // Make 5 concurrent calls for the same key.
+    wg.Add(n)
+    for i := range n {
+        wg.Go(func() {
+            defer wg.Done()
+
+            // The function will only be executed for the first call.
+            // All other calls will wait and receive the same result.
+            v, shared, err := g.Do(context.Background(), "user-profile", func(ctx context.Context) (string, error) {
+                fmt.Println("Fetching user profile from database...")
+                time.Sleep(100 * time.Millisecond) // Simulate slow DB query
+                return "User data for John Doe", nil
+            })
+
+            if err != nil {
+                fmt.Printf("Goroutine %d: encountered an error: %v\n", i, err)
+                return
+            }
+
+            fmt.Printf("Goroutine %d: got result '%s' (shared: %t)\n", i, v, shared)
+        })
+    }
+
+    wg.Wait()
 }
 ```
 

examples_test.go

@@ -32,17 +32,15 @@ func ExampleGroup_Do() {
 		return "result", nil
 	}
 
-	for i := 0; i < 10; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
+	for range 10 {
+		wg.Go(func() {
 			v, shared, err := g.Do(context.Background(), "key", fn)
 			if err != nil {
 				log.Printf("unexpected error: %v", err)
 				return
 			}
 			fmt.Printf("Got result: %s, Shared: %t\n", v, shared)
-		}()
+		})
 	}
 
 	wg.Wait()
@@ -88,10 +86,8 @@ func ExampleGroup_Do_panic() {
 		panic("critical failure")
 	}
 
-	for i := 0; i < 3; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
+	for range 3 {
+		wg.Go(func() {
 			defer func() {
 				if r := recover(); r != nil {
 					// Check if the recovered error contains the panic message and stack trace.
@@ -101,7 +97,7 @@ func ExampleGroup_Do_panic() {
 				}
 			}()
 			_, _, _ = g.Do(context.Background(), "key", fn)
-		}()
+		})
 	}
 
 	wg.Wait()