Rerun tools/build to reformat

examples/worker-pools/worker-pools.go

@@ -12,40 +12,40 @@ import "time"
 // results on `results`. We'll sleep a second per job to
 // simulate an expensive task.
 func worker(id int, jobs <-chan int, results chan<- int) {
-	for j := range jobs {
-		fmt.Println("worker", id, "started  job", j)
-		time.Sleep(time.Second)
-		fmt.Println("worker", id, "finished job", j)
-		results <- j * 2
-	}
+    for j := range jobs {
+        fmt.Println("worker", id, "started  job", j)
+        time.Sleep(time.Second)
+        fmt.Println("worker", id, "finished job", j)
+        results <- j * 2
+    }
 }
 
 func main() {
 
-	// In order to use our pool of workers we need to send
-	// them work and collect their results. We make 2
-	// channels for this.
-	jobs := make(chan int, 100)
-	results := make(chan int, 100)
+    // In order to use our pool of workers we need to send
+    // them work and collect their results. We make 2
+    // channels for this.
+    jobs := make(chan int, 100)
+    results := make(chan int, 100)
 
-	// This starts up 3 workers, initially blocked
-	// because there are no jobs yet.
-	for w := 1; w <= 3; w++ {
-		go worker(w, jobs, results)
-	}
+    // This starts up 3 workers, initially blocked
+    // because there are no jobs yet.
+    for w := 1; w <= 3; w++ {
+        go worker(w, jobs, results)
+    }
 
-	// Here we send 5 `jobs` and then `close` that
-	// channel to indicate that's all the work we have.
-	for j := 1; j <= 5; j++ {
-		jobs <- j
-	}
-	close(jobs)
+    // Here we send 5 `jobs` and then `close` that
+    // channel to indicate that's all the work we have.
+    for j := 1; j <= 5; j++ {
+        jobs <- j
+    }
+    close(jobs)
 
-	// Finally we collect all the results of the work.
-	// This also ensures that the worker goroutines have
-	// finished. An alternative way to wait for multiple
-	// goroutines is to use a [WaitGroup](waitgroup).
-	for a := 1; a <= 5; a++ {
-		<-results
-	}
+    // Finally we collect all the results of the work.
+    // This also ensures that the worker goroutines have
+    // finished. An alternative way to wait for multiple
+    // goroutines is to use a [WaitGroup](waitgroup).
+    for a := 1; a <= 5; a++ {
+        <-results
+    }
 }

examples/worker-pools/worker-pools.hash

@@ -1,2 +1,2 @@
-bfd2824b3840ff67fa9a0218c7be66647b4bf3d9
-IQestAFcxLh
+3f7712d470dcbfc0cdddc939bb80814baaff8bb0
+Q5r-XtrWWL-

public/worker-pools

@@ -40,7 +40,7 @@ a <em>worker pool</em> using goroutines and channels.</p>
             
           </td>
           <td class="code leading">
-	        <a href="http://play.golang.org/p/IQestAFcxLh"><img title="Run code" src="play.png" class="run" /></a>
+	        <a href="http://play.golang.org/p/Q5r-XtrWWL-"><img title="Run code" src="play.png" class="run" /></a>
             <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
 </pre></div>
 
@@ -150,8 +150,7 @@ channel to indicate that&rsquo;s all the work we have.</p>
             <p>Finally we collect all the results of the work.
 This also ensures that the worker goroutines have
 finished. An alternative way to wait for multiple
-goroutines that&rsquo;s useful in many scenarios is
-to use a <a href="waitgroup">WaitGroup</a>.</p>
+goroutines is to use a <a href="waitgroup">WaitGroup</a>.</p>
 
           </td>
           <td class="code">