Fix typo

Fixes #610

README.md

@@ -65,13 +65,11 @@ Contributor translations of the Go by Example site are available in:
 
 * [Chinese](https://gobyexample-cn.github.io/) by [gobyexample-cn](https://github.com/gobyexample-cn)
 * [French](http://le-go-par-l-exemple.keiruaprod.fr) by [keirua](https://github.com/keirua/gobyexample)
-* [Italian](https://gobyexample.it) by the [Go Italian community](https://github.com/golangit/gobyexample-it)
 * [Japanese](http://spinute.org/go-by-example) by [spinute](https://github.com/spinute)
 * [Korean](https://mingrammer.com/gobyexample/) by [mingrammer](https://github.com/mingrammer)
 * [Russian](https://gobyexample.com.ru/) by [badkaktus](https://github.com/badkaktus)
 * [Ukrainian](https://butuzov.github.io/gobyexample/) by [butuzov](https://github.com/butuzov/gobyexample)
 * [Brazilian Portuguese](https://lcslitx.github.io/GoEmExemplos/) by [lcslitx](https://github.com/LCSLITX)
-* [Vietnamese](https://gobyexample.vn/) by [s6k Gopher](https://github.com/s6k-gopher/gobyexample-vn)
 * [Burmese](https://setkyar.github.io/gobyexample) by [Set Kyar Wa Lar](https://github.com/setkyar/gobyexample)
 
 ### Thanks

examples/arrays/arrays.go

@@ -45,8 +45,8 @@ func main() {
 	// compose types to build multi-dimensional data
 	// structures.
 	var twoD [2][3]int
-	for i := 0; i < 2; i++ {
-		for j := 0; j < 3; j++ {
+	for i := range 2 {
+		for j := range 3 {
 			twoD[i][j] = i + j
 		}
 	}

examples/arrays/arrays.hash

@@ -1,2 +1,2 @@
-789f9faa91c359e5337ace4f80b38428f39d4e7b
-zVIFeNnUdwv
+96cbe484a18a0dd8c1839a92963447bed94cc997
+-NFSggT7dFH

examples/atomic-counters/atomic-counters.go

@@ -25,11 +25,11 @@ func main() {
 
 	// We'll start 50 goroutines that each increment the
 	// counter exactly 1000 times.
-	for i := 0; i < 50; i++ {
+	for range 50 {
 		wg.Add(1)
 
 		go func() {
-			for c := 0; c < 1000; c++ {
+			for range 1000 {
 
 				// To atomically increment the counter we use `Add`.
 				ops.Add(1)

examples/atomic-counters/atomic-counters.hash

@@ -1,2 +1,2 @@
-3435537238237eb363f652dddb405788fec98c8b
-HWE6h4-y-Fw
+cb0a6d420c43d4d3128266738622a6a45b56bcfd
+MmpbKHe1ldr

examples/context/context.go

@@ -1,5 +1,5 @@
 // In the previous example we looked at setting up a simple
-// [HTTP server](http-servers). HTTP servers are useful for
+// [HTTP server](http-server). HTTP servers are useful for
 // demonstrating the usage of `context.Context` for
 // controlling cancellation. A `Context` carries deadlines,
 // cancellation signals, and other request-scoped values

examples/context/context.hash

@@ -1,2 +1,2 @@
-a9537bfea55bca15d8db1c453e2d9852f9d447e1
-0_bu1o8rIBO
+94a35a6172346b56737ed907a2320bd30f98995d
+7G1TlQrnbF1

examples/goroutines/goroutines.go

@@ -8,7 +8,7 @@ import (
 )
 
 func f(from string) {
-	for i := 0; i < 3; i++ {
+	for i := range 3 {
 		fmt.Println(from, ":", i)
 	}
 }

examples/goroutines/goroutines.hash

@@ -1,2 +1,2 @@
-08aa2b9e426724e07ec83162eb6892648ccc7fd5
-I7scqRijEJt
+b7455068d7f944d7c1a2764e5ec05bee53296e62
+0fx_WokYVFO

examples/mutexes/mutexes.go

@@ -42,7 +42,7 @@ func main() {
 	// This function increments a named counter
 	// in a loop.
 	doIncrement := func(name string, n int) {
-		for i := 0; i < n; i++ {
+		for range n {
 			c.inc(name)
 		}
 		wg.Done()

examples/mutexes/mutexes.hash

@@ -1,2 +1,2 @@
-d858d466e806a9dcb5992c8c2a3c6dc377a7a904
-JU735qy2UmB
+1c56c75162419ced8437b7ebe53ee65e5479f645
+CawzyQnvH6W

examples/rate-limiting/rate-limiting.go

@@ -44,7 +44,7 @@ func main() {
 	burstyLimiter := make(chan time.Time, 3)
 
 	// Fill up the channel to represent allowed bursting.
-	for i := 0; i < 3; i++ {
+	for range 3 {
 		burstyLimiter <- time.Now()
 	}
 

examples/rate-limiting/rate-limiting.hash

@@ -1,2 +1,2 @@
-4f327f5bd5ac199ae5590652563ea6ca4ce7eff5
-lqf7pC2FUeT
+c1eee474067ad718e57df5c55242ba4711e7bcb7
+y9V3goQfy5m

examples/select/select.go

@@ -29,7 +29,7 @@ func main() {
 
 	// We'll use `select` to await both of these values
 	// simultaneously, printing each one as it arrives.
-	for i := 0; i < 2; i++ {
+	for range 2 {
 		select {
 		case msg1 := <-c1:
 			fmt.Println("received", msg1)

examples/select/select.hash

@@ -1,2 +1,2 @@
-33fe111b666efb3243c9cbd0ba12b2e795d90fab
-FzONhs4-tae
+b10a3f618c232683fba207e56e4b4cda812fd377
+dOrjUfgGwB2

examples/slices/slices.go

@@ -17,7 +17,7 @@ func main() {
 	var s []string
 	fmt.Println("uninit:", s, s == nil, len(s) == 0)
 
-	// To create an empty slice with non-zero length, use
+	// To create a slice with non-zero length, use
 	// the builtin `make`. Here we make a slice of
 	// `string`s of length `3` (initially zero-valued).
 	// By default a new slice's capacity is equal to its
@@ -84,10 +84,10 @@ func main() {
 	// structures. The length of the inner slices can
 	// vary, unlike with multi-dimensional arrays.
 	twoD := make([][]int, 3)
-	for i := 0; i < 3; i++ {
+	for i := range 3 {
 		innerLen := i + 1
 		twoD[i] = make([]int, innerLen)
-		for j := 0; j < innerLen; j++ {
+		for j := range innerLen {
 			twoD[i][j] = i + j
 		}
 	}

examples/slices/slices.hash

@@ -1,2 +1,2 @@
-522c14373ae9581dd3001be32530cdf940637646
-kiy1StxorBF
+4db1907fd5137325a1e3c3fc50950d4250ed1a4b
+9-U3-8sKQun

examples/stateful-goroutines/stateful-goroutines.go

@@ -73,7 +73,7 @@ func main() {
 	// Each read requires constructing a `readOp`, sending
 	// it over the `reads` channel, and then receiving the
 	// result over the provided `resp` channel.
-	for r := 0; r < 100; r++ {
+	for range 100 {
 		go func() {
 			for {
 				read := readOp{
@@ -89,7 +89,7 @@ func main() {
 
 	// We start 10 writes as well, using a similar
 	// approach.
-	for w := 0; w < 10; w++ {
+	for range 10 {
 		go func() {
 			for {
 				write := writeOp{

examples/stateful-goroutines/stateful-goroutines.hash

@@ -1,2 +1,2 @@
-04a59d09868df58e9edf5930d38efd25cbb92861
-TBcWd-OfnaA
+ae1a9ffac4407f564ae1458f2464d3c87deaf2df
+uX6AcrTXA-a

examples/string-functions/string-functions.go

@@ -18,7 +18,7 @@ func main() {
 	// Here's a sample of the functions available in
 	// `strings`. Since these are functions from the
 	// package, not methods on the string object itself,
-	// we need pass the string in question as the first
+	// we need to pass the string in question as the first
 	// argument to the function. You can find more
 	// functions in the [`strings`](https://pkg.go.dev/strings)
 	// package docs.

examples/string-functions/string-functions.hash

@@ -1,2 +1,2 @@
-a8fc7e03fd17f6d432adf2f0e991461630ce4350
-DSKkoyx9Rcy
+e1e2ea01b9c79fecebfece602915e9367b02a083
+wKSAzxfs96O

examples/testing-and-benchmarking/main_test.go

@@ -54,7 +54,7 @@ func TestIntMinTableDriven(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		// t.Run enables running "subtests", one for each
+		// `t.Run` enables running "subtests", one for each
 		// table entry. These are shown separately
 		// when executing `go test -v`.
 		testname := fmt.Sprintf("%d,%d", tt.a, tt.b)
@@ -68,13 +68,14 @@ func TestIntMinTableDriven(t *testing.T) {
 }
 
 // Benchmark tests typically go in `_test.go` files and are
-// named beginning with `Benchmark`. The `testing` runner
-// executes each benchmark function several times, increasing
-// `b.N` on each run until it collects a precise measurement.
+// named beginning with `Benchmark`.
+// Any code that's required for the benchmark to run but should
+// not be measured goes before this loop.
 func BenchmarkIntMin(b *testing.B) {
-	// Typically the benchmark runs a function we're
-	// benchmarking in a loop `b.N` times.
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
+		// The benchmark runner will automatically execute this loop
+		// body many times to determine a reasonable estimate of the
+		// run-time of a single iteration.
 		IntMin(1, 2)
 	}
 }

examples/testing-and-benchmarking/testing-and-benchmarking.hash

@@ -0,0 +1,2 @@
+565e50f23b399cdbca4aedeb8b62b9f6ad097443
+osZckbKSkse

examples/testing-and-benchmarking/testing.hash

@@ -1,2 +0,0 @@
-3671aaf0eee9f6d2b68e51b09997be767edfe97c
-PlzU16wwEWE

examples/timers/timers.sh

@@ -1,6 +1,6 @@
-// The first timer will fire ~2s after we start the
-// program, but the second should be stopped before it has
-// a chance to fire.
+# The first timer will fire ~2s after we start the
+# program, but the second should be stopped before it has
+# a chance to fire.
 $ go run timers.go
 Timer 1 fired
 Timer 2 stopped

go.mod

@@ -1,6 +1,6 @@
 module github.com/mmcgrana/gobyexample
 
-go 1.23.0
+go 1.24.0
 
 require (
 	github.com/alecthomas/chroma/v2 v2.10.0

public/arrays

@@ -47,7 +47,7 @@ scenarios.</p>
             
           </td>
           <td class="code leading">
-            <a href="https://go.dev/play/p/zVIFeNnUdwv"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
+            <a href="https://go.dev/play/p/-NFSggT7dFH"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
           <pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">main</span></span></span></code></pre>
           </td>
         </tr>
@@ -162,8 +162,8 @@ structures.</p>
           <td class="code leading">
             
           <pre class="chroma"><code><span class="line"><span class="cl">    <span class="kd">var</span> <span class="nx">twoD</span> <span class="p">[</span><span class="mi">2</span><span class="p">][</span><span class="mi">3</span><span class="p">]</span><span class="kt">int</span>
-</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="p">&lt;</span> <span class="mi">2</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">{</span>
-</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="nx">j</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">j</span> <span class="p">&lt;</span> <span class="mi">3</span><span class="p">;</span> <span class="nx">j</span><span class="o">++</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="k">range</span> <span class="mi">2</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="nx">j</span> <span class="o">:=</span> <span class="k">range</span> <span class="mi">3</span> <span class="p">{</span>
 </span></span><span class="line"><span class="cl">            <span class="nx">twoD</span><span class="p">[</span><span class="nx">i</span><span class="p">][</span><span class="nx">j</span><span class="p">]</span> <span class="p">=</span> <span class="nx">i</span> <span class="o">+</span> <span class="nx">j</span>
 </span></span><span class="line"><span class="cl">        <span class="p">}</span>
 </span></span><span class="line"><span class="cl">    <span class="p">}</span>
@@ -228,7 +228,7 @@ when printed with <code>fmt.Println</code>.</p>
     </div>
     <script>
       var codeLines = [];
-      codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import \"fmt\"\u000A');codeLines.push('func main() {\u000A');codeLines.push('    var a [5]int\u000A    fmt.Println(\"emp:\", a)\u000A');codeLines.push('    a[4] \u003D 100\u000A    fmt.Println(\"set:\", a)\u000A    fmt.Println(\"get:\", a[4])\u000A');codeLines.push('    fmt.Println(\"len:\", len(a))\u000A');codeLines.push('    b :\u003D [5]int{1, 2, 3, 4, 5}\u000A    fmt.Println(\"dcl:\", b)\u000A');codeLines.push('    b \u003D [...]int{1, 2, 3, 4, 5}\u000A    fmt.Println(\"dcl:\", b)\u000A');codeLines.push('    b \u003D [...]int{100, 3: 400, 500}\u000A    fmt.Println(\"idx:\", b)\u000A');codeLines.push('    var twoD [2][3]int\u000A    for i :\u003D 0; i \u003C 2; i++ {\u000A        for j :\u003D 0; j \u003C 3; j++ {\u000A            twoD[i][j] \u003D i + j\u000A        }\u000A    }\u000A    fmt.Println(\"2d: \", twoD)\u000A');codeLines.push('    twoD \u003D [2][3]int{\u000A        {1, 2, 3},\u000A        {1, 2, 3},\u000A    }\u000A    fmt.Println(\"2d: \", twoD)\u000A}\u000A');codeLines.push('');
+      codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import \"fmt\"\u000A');codeLines.push('func main() {\u000A');codeLines.push('    var a [5]int\u000A    fmt.Println(\"emp:\", a)\u000A');codeLines.push('    a[4] \u003D 100\u000A    fmt.Println(\"set:\", a)\u000A    fmt.Println(\"get:\", a[4])\u000A');codeLines.push('    fmt.Println(\"len:\", len(a))\u000A');codeLines.push('    b :\u003D [5]int{1, 2, 3, 4, 5}\u000A    fmt.Println(\"dcl:\", b)\u000A');codeLines.push('    b \u003D [...]int{1, 2, 3, 4, 5}\u000A    fmt.Println(\"dcl:\", b)\u000A');codeLines.push('    b \u003D [...]int{100, 3: 400, 500}\u000A    fmt.Println(\"idx:\", b)\u000A');codeLines.push('    var twoD [2][3]int\u000A    for i :\u003D range 2 {\u000A        for j :\u003D range 3 {\u000A            twoD[i][j] \u003D i + j\u000A        }\u000A    }\u000A    fmt.Println(\"2d: \", twoD)\u000A');codeLines.push('    twoD \u003D [2][3]int{\u000A        {1, 2, 3},\u000A        {1, 2, 3},\u000A    }\u000A    fmt.Println(\"2d: \", twoD)\u000A}\u000A');codeLines.push('');
     </script>
     <script src="site.js" async></script>
   </body>

public/atomic-counters

@@ -49,7 +49,7 @@ counters</em> accessed by multiple goroutines.</p>
             
           </td>
           <td class="code leading">
-            <a href="https://go.dev/play/p/HWE6h4-y-Fw"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
+            <a href="https://go.dev/play/p/MmpbKHe1ldr"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
           <pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">main</span></span></span></code></pre>
           </td>
         </tr>
@@ -110,7 +110,7 @@ counter exactly 1000 times.</p>
           </td>
           <td class="code leading">
             
-          <pre class="chroma"><code><span class="line"><span class="cl">    <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="p">&lt;</span> <span class="mi">50</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">{</span>
+          <pre class="chroma"><code><span class="line"><span class="cl">    <span class="k">for</span> <span class="k">range</span> <span class="mi">50</span> <span class="p">{</span>
 </span></span><span class="line"><span class="cl">        <span class="nx">wg</span><span class="p">.</span><span class="nf">Add</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span></span></span></code></pre>
           </td>
         </tr>
@@ -122,7 +122,7 @@ counter exactly 1000 times.</p>
           <td class="code leading">
             
           <pre class="chroma"><code><span class="line"><span class="cl">        <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
-</span></span><span class="line"><span class="cl">            <span class="k">for</span> <span class="nx">c</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">c</span> <span class="p">&lt;</span> <span class="mi">1000</span><span class="p">;</span> <span class="nx">c</span><span class="o">++</span> <span class="p">{</span></span></span></code></pre>
+</span></span><span class="line"><span class="cl">            <span class="k">for</span> <span class="k">range</span> <span class="mi">1000</span> <span class="p">{</span></span></span></code></pre>
           </td>
         </tr>
         
@@ -224,7 +224,7 @@ state.</p>
     </div>
     <script>
       var codeLines = [];
-      codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A    \"fmt\"\u000A    \"sync\"\u000A    \"sync/atomic\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push('    var ops atomic.Uint64\u000A');codeLines.push('    var wg sync.WaitGroup\u000A');codeLines.push('    for i :\u003D 0; i \u003C 50; i++ {\u000A        wg.Add(1)\u000A');codeLines.push('        go func() {\u000A            for c :\u003D 0; c \u003C 1000; c++ {\u000A');codeLines.push('                ops.Add(1)\u000A            }\u000A');codeLines.push('            wg.Done()\u000A        }()\u000A    }\u000A');codeLines.push('    wg.Wait()\u000A');codeLines.push('    fmt.Println(\"ops:\", ops.Load())\u000A}\u000A');codeLines.push('');codeLines.push('');
+      codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A    \"fmt\"\u000A    \"sync\"\u000A    \"sync/atomic\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push('    var ops atomic.Uint64\u000A');codeLines.push('    var wg sync.WaitGroup\u000A');codeLines.push('    for range 50 {\u000A        wg.Add(1)\u000A');codeLines.push('        go func() {\u000A            for range 1000 {\u000A');codeLines.push('                ops.Add(1)\u000A            }\u000A');codeLines.push('            wg.Done()\u000A        }()\u000A    }\u000A');codeLines.push('    wg.Wait()\u000A');codeLines.push('    fmt.Println(\"ops:\", ops.Load())\u000A}\u000A');codeLines.push('');codeLines.push('');
     </script>
     <script src="site.js" async></script>
   </body>

public/context

@@ -31,7 +31,7 @@
         <tr>
           <td class="docs">
             <p>In the previous example we looked at setting up a simple
-<a href="http-servers">HTTP server</a>. HTTP servers are useful for
+<a href="http-server">HTTP server</a>. HTTP servers are useful for
 demonstrating the usage of <code>context.Context</code> for
 controlling cancellation. A <code>Context</code> carries deadlines,
 cancellation signals, and other request-scoped values
@@ -39,7 +39,7 @@ across API boundaries and goroutines.</p>
 
           </td>
           <td class="code leading">
-            <a href="https://go.dev/play/p/0_bu1o8rIBO"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
+            <a href="https://go.dev/play/p/7G1TlQrnbF1"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
           <pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">main</span></span></span></code></pre>
           </td>
         </tr>

public/goroutines

@@ -44,7 +44,7 @@
             
           </td>
           <td class="code leading">
-            <a href="https://go.dev/play/p/I7scqRijEJt"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
+            <a href="https://go.dev/play/p/0fx_WokYVFO"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
           <pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">main</span></span></span></code></pre>
           </td>
         </tr>
@@ -69,7 +69,7 @@
           <td class="code leading">
             
           <pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">f</span><span class="p">(</span><span class="nx">from</span> <span class="kt">string</span><span class="p">)</span> <span class="p">{</span>
-</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="p">&lt;</span> <span class="mi">3</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="k">range</span> <span class="mi">3</span> <span class="p">{</span>
 </span></span><span class="line"><span class="cl">        <span class="nx">fmt</span><span class="p">.</span><span class="nf">Println</span><span class="p">(</span><span class="nx">from</span><span class="p">,</span> <span class="s">&#34;:&#34;</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span>
 </span></span><span class="line"><span class="cl">    <span class="p">}</span>
 </span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre>
@@ -195,7 +195,7 @@ concurrent Go programs: channels.</p>
     </div>
     <script>
       var codeLines = [];
-      codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A    \"fmt\"\u000A    \"time\"\u000A)\u000A');codeLines.push('func f(from string) {\u000A    for i :\u003D 0; i \u003C 3; i++ {\u000A        fmt.Println(from, \":\", i)\u000A    }\u000A}\u000A');codeLines.push('func main() {\u000A');codeLines.push('    f(\"direct\")\u000A');codeLines.push('    go f(\"goroutine\")\u000A');codeLines.push('    go func(msg string) {\u000A        fmt.Println(msg)\u000A    }(\"going\")\u000A');codeLines.push('    time.Sleep(time.Second)\u000A    fmt.Println(\"done\")\u000A}\u000A');codeLines.push('');codeLines.push('');
+      codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A    \"fmt\"\u000A    \"time\"\u000A)\u000A');codeLines.push('func f(from string) {\u000A    for i :\u003D range 3 {\u000A        fmt.Println(from, \":\", i)\u000A    }\u000A}\u000A');codeLines.push('func main() {\u000A');codeLines.push('    f(\"direct\")\u000A');codeLines.push('    go f(\"goroutine\")\u000A');codeLines.push('    go func(msg string) {\u000A        fmt.Println(msg)\u000A    }(\"going\")\u000A');codeLines.push('    time.Sleep(time.Second)\u000A    fmt.Println(\"done\")\u000A}\u000A');codeLines.push('');codeLines.push('');
     </script>
     <script src="site.js" async></script>
   </body>

public/mutexes

@@ -47,7 +47,7 @@ to safely access data across multiple goroutines.</p>
             
           </td>
           <td class="code leading">
-            <a href="https://go.dev/play/p/JU735qy2UmB"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
+            <a href="https://go.dev/play/p/CawzyQnvH6W"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
           <pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">main</span></span></span></code></pre>
           </td>
         </tr>
@@ -153,7 +153,7 @@ in a loop.</p>
           <td class="code leading">
             
           <pre class="chroma"><code><span class="line"><span class="cl">    <span class="nx">doIncrement</span> <span class="o">:=</span> <span class="kd">func</span><span class="p">(</span><span class="nx">name</span> <span class="kt">string</span><span class="p">,</span> <span class="nx">n</span> <span class="kt">int</span><span class="p">)</span> <span class="p">{</span>
-</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="p">&lt;</span> <span class="nx">n</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="k">range</span> <span class="nx">n</span> <span class="p">{</span>
 </span></span><span class="line"><span class="cl">            <span class="nx">c</span><span class="p">.</span><span class="nf">inc</span><span class="p">(</span><span class="nx">name</span><span class="p">)</span>
 </span></span><span class="line"><span class="cl">        <span class="p">}</span>
 </span></span><span class="line"><span class="cl">        <span class="nx">wg</span><span class="p">.</span><span class="nf">Done</span><span class="p">()</span>
@@ -234,7 +234,7 @@ management task using only goroutines and channels.</p>
     </div>
     <script>
       var codeLines = [];
-      codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A    \"fmt\"\u000A    \"sync\"\u000A)\u000A');codeLines.push('type Container struct {\u000A    mu       sync.Mutex\u000A    counters map[string]int\u000A}\u000A');codeLines.push('func (c *Container) inc(name string) {\u000A');codeLines.push('    c.mu.Lock()\u000A    defer c.mu.Unlock()\u000A    c.counters[name]++\u000A}\u000A');codeLines.push('func main() {\u000A    c :\u003D Container{\u000A');codeLines.push('        counters: map[string]int{\"a\": 0, \"b\": 0},\u000A    }\u000A');codeLines.push('    var wg sync.WaitGroup\u000A');codeLines.push('    doIncrement :\u003D func(name string, n int) {\u000A        for i :\u003D 0; i \u003C n; i++ {\u000A            c.inc(name)\u000A        }\u000A        wg.Done()\u000A    }\u000A');codeLines.push('    wg.Add(3)\u000A    go doIncrement(\"a\", 10000)\u000A    go doIncrement(\"a\", 10000)\u000A    go doIncrement(\"b\", 10000)\u000A');codeLines.push('    wg.Wait()\u000A    fmt.Println(c.counters)\u000A}\u000A');codeLines.push('');codeLines.push('');
+      codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A    \"fmt\"\u000A    \"sync\"\u000A)\u000A');codeLines.push('type Container struct {\u000A    mu       sync.Mutex\u000A    counters map[string]int\u000A}\u000A');codeLines.push('func (c *Container) inc(name string) {\u000A');codeLines.push('    c.mu.Lock()\u000A    defer c.mu.Unlock()\u000A    c.counters[name]++\u000A}\u000A');codeLines.push('func main() {\u000A    c :\u003D Container{\u000A');codeLines.push('        counters: map[string]int{\"a\": 0, \"b\": 0},\u000A    }\u000A');codeLines.push('    var wg sync.WaitGroup\u000A');codeLines.push('    doIncrement :\u003D func(name string, n int) {\u000A        for range n {\u000A            c.inc(name)\u000A        }\u000A        wg.Done()\u000A    }\u000A');codeLines.push('    wg.Add(3)\u000A    go doIncrement(\"a\", 10000)\u000A    go doIncrement(\"a\", 10000)\u000A    go doIncrement(\"b\", 10000)\u000A');codeLines.push('    wg.Wait()\u000A    fmt.Println(c.counters)\u000A}\u000A');codeLines.push('');codeLines.push('');
     </script>
     <script src="site.js" async></script>
   </body>

public/rate-limiting

@@ -48,7 +48,7 @@ channels, and <a href="tickers">tickers</a>.</p>
             
           </td>
           <td class="code leading">
-            <a href="https://go.dev/play/p/lqf7pC2FUeT"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
+            <a href="https://go.dev/play/p/y9V3goQfy5m"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
           <pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">main</span></span></span></code></pre>
           </td>
         </tr>
@@ -145,7 +145,7 @@ channel will allow bursts of up to 3 events.</p>
           </td>
           <td class="code leading">
             
-          <pre class="chroma"><code><span class="line"><span class="cl">    <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="p">&lt;</span> <span class="mi">3</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">{</span>
+          <pre class="chroma"><code><span class="line"><span class="cl">    <span class="k">for</span> <span class="k">range</span> <span class="mi">3</span> <span class="p">{</span>
 </span></span><span class="line"><span class="cl">        <span class="nx">burstyLimiter</span> <span class="o">&lt;-</span> <span class="nx">time</span><span class="p">.</span><span class="nf">Now</span><span class="p">()</span>
 </span></span><span class="line"><span class="cl">    <span class="p">}</span></span></span></code></pre>
           </td>
@@ -242,7 +242,7 @@ then serve the remaining 2 with ~200ms delays each.</p>
     </div>
     <script>
       var codeLines = [];
-      codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A    \"fmt\"\u000A    \"time\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push('    requests :\u003D make(chan int, 5)\u000A    for i :\u003D 1; i \u003C\u003D 5; i++ {\u000A        requests \u003C- i\u000A    }\u000A    close(requests)\u000A');codeLines.push('    limiter :\u003D time.Tick(200 * time.Millisecond)\u000A');codeLines.push('    for req :\u003D range requests {\u000A        \u003C-limiter\u000A        fmt.Println(\"request\", req, time.Now())\u000A    }\u000A');codeLines.push('    burstyLimiter :\u003D make(chan time.Time, 3)\u000A');codeLines.push('    for i :\u003D 0; i \u003C 3; i++ {\u000A        burstyLimiter \u003C- time.Now()\u000A    }\u000A');codeLines.push('    go func() {\u000A        for t :\u003D range time.Tick(200 * time.Millisecond) {\u000A            burstyLimiter \u003C- t\u000A        }\u000A    }()\u000A');codeLines.push('    burstyRequests :\u003D make(chan int, 5)\u000A    for i :\u003D 1; i \u003C\u003D 5; i++ {\u000A        burstyRequests \u003C- i\u000A    }\u000A    close(burstyRequests)\u000A    for req :\u003D range burstyRequests {\u000A        \u003C-burstyLimiter\u000A        fmt.Println(\"request\", req, time.Now())\u000A    }\u000A}\u000A');codeLines.push('');codeLines.push('');
+      codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A    \"fmt\"\u000A    \"time\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push('    requests :\u003D make(chan int, 5)\u000A    for i :\u003D 1; i \u003C\u003D 5; i++ {\u000A        requests \u003C- i\u000A    }\u000A    close(requests)\u000A');codeLines.push('    limiter :\u003D time.Tick(200 * time.Millisecond)\u000A');codeLines.push('    for req :\u003D range requests {\u000A        \u003C-limiter\u000A        fmt.Println(\"request\", req, time.Now())\u000A    }\u000A');codeLines.push('    burstyLimiter :\u003D make(chan time.Time, 3)\u000A');codeLines.push('    for range 3 {\u000A        burstyLimiter \u003C- time.Now()\u000A    }\u000A');codeLines.push('    go func() {\u000A        for t :\u003D range time.Tick(200 * time.Millisecond) {\u000A            burstyLimiter \u003C- t\u000A        }\u000A    }()\u000A');codeLines.push('    burstyRequests :\u003D make(chan int, 5)\u000A    for i :\u003D 1; i \u003C\u003D 5; i++ {\u000A        burstyRequests \u003C- i\u000A    }\u000A    close(burstyRequests)\u000A    for req :\u003D range burstyRequests {\u000A        \u003C-burstyLimiter\u000A        fmt.Println(\"request\", req, time.Now())\u000A    }\u000A}\u000A');codeLines.push('');codeLines.push('');
     </script>
     <script src="site.js" async></script>
   </body>

public/select

@@ -46,7 +46,7 @@ select is a powerful feature of Go.</p>
             
           </td>
           <td class="code leading">
-            <a href="https://go.dev/play/p/FzONhs4-tae"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
+            <a href="https://go.dev/play/p/dOrjUfgGwB2"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
           <pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">main</span></span></span></code></pre>
           </td>
         </tr>
@@ -114,7 +114,7 @@ simultaneously, printing each one as it arrives.</p>
           </td>
           <td class="code">
             
-          <pre class="chroma"><code><span class="line"><span class="cl">    <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="p">&lt;</span> <span class="mi">2</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">{</span>
+          <pre class="chroma"><code><span class="line"><span class="cl">    <span class="k">for</span> <span class="k">range</span> <span class="mi">2</span> <span class="p">{</span>
 </span></span><span class="line"><span class="cl">        <span class="k">select</span> <span class="p">{</span>
 </span></span><span class="line"><span class="cl">        <span class="k">case</span> <span class="nx">msg1</span> <span class="o">:=</span> <span class="o">&lt;-</span><span class="nx">c1</span><span class="p">:</span>
 </span></span><span class="line"><span class="cl">            <span class="nx">fmt</span><span class="p">.</span><span class="nf">Println</span><span class="p">(</span><span class="s">&#34;received&#34;</span><span class="p">,</span> <span class="nx">msg1</span><span class="p">)</span>
@@ -172,7 +172,7 @@ concurrently.</p>
     </div>
     <script>
       var codeLines = [];
-      codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A    \"fmt\"\u000A    \"time\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push('    c1 :\u003D make(chan string)\u000A    c2 :\u003D make(chan string)\u000A');codeLines.push('    go func() {\u000A        time.Sleep(1 * time.Second)\u000A        c1 \u003C- \"one\"\u000A    }()\u000A    go func() {\u000A        time.Sleep(2 * time.Second)\u000A        c2 \u003C- \"two\"\u000A    }()\u000A');codeLines.push('    for i :\u003D 0; i \u003C 2; i++ {\u000A        select {\u000A        case msg1 :\u003D \u003C-c1:\u000A            fmt.Println(\"received\", msg1)\u000A        case msg2 :\u003D \u003C-c2:\u000A            fmt.Println(\"received\", msg2)\u000A        }\u000A    }\u000A}\u000A');codeLines.push('');codeLines.push('');
+      codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A    \"fmt\"\u000A    \"time\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push('    c1 :\u003D make(chan string)\u000A    c2 :\u003D make(chan string)\u000A');codeLines.push('    go func() {\u000A        time.Sleep(1 * time.Second)\u000A        c1 \u003C- \"one\"\u000A    }()\u000A    go func() {\u000A        time.Sleep(2 * time.Second)\u000A        c2 \u003C- \"two\"\u000A    }()\u000A');codeLines.push('    for range 2 {\u000A        select {\u000A        case msg1 :\u003D \u003C-c1:\u000A            fmt.Println(\"received\", msg1)\u000A        case msg2 :\u003D \u003C-c2:\u000A            fmt.Println(\"received\", msg2)\u000A        }\u000A    }\u000A}\u000A');codeLines.push('');codeLines.push('');
     </script>
     <script src="site.js" async></script>
   </body>

public/slices

@@ -45,7 +45,7 @@ a more powerful interface to sequences than arrays.</p>
             
           </td>
           <td class="code leading">
-            <a href="https://go.dev/play/p/kiy1StxorBF"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
+            <a href="https://go.dev/play/p/9-U3-8sKQun"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
           <pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">main</span></span></span></code></pre>
           </td>
         </tr>
@@ -90,7 +90,7 @@ length 0.</p>
         
         <tr>
           <td class="docs">
-            <p>To create an empty slice with non-zero length, use
+            <p>To create a slice with non-zero length, use
 the builtin <code>make</code>. Here we make a slice of
 <code>string</code>s of length <code>3</code> (initially zero-valued).
 By default a new slice&rsquo;s capacity is equal to its
@@ -241,10 +241,10 @@ vary, unlike with multi-dimensional arrays.</p>
           <td class="code">
             
           <pre class="chroma"><code><span class="line"><span class="cl">    <span class="nx">twoD</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">([][]</span><span class="kt">int</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
-</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="p">&lt;</span> <span class="mi">3</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="k">range</span> <span class="mi">3</span> <span class="p">{</span>
 </span></span><span class="line"><span class="cl">        <span class="nx">innerLen</span> <span class="o">:=</span> <span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span>
 </span></span><span class="line"><span class="cl">        <span class="nx">twoD</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="p">=</span> <span class="nb">make</span><span class="p">([]</span><span class="kt">int</span><span class="p">,</span> <span class="nx">innerLen</span><span class="p">)</span>
-</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="nx">j</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">j</span> <span class="p">&lt;</span> <span class="nx">innerLen</span><span class="p">;</span> <span class="nx">j</span><span class="o">++</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="nx">j</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">innerLen</span> <span class="p">{</span>
 </span></span><span class="line"><span class="cl">            <span class="nx">twoD</span><span class="p">[</span><span class="nx">i</span><span class="p">][</span><span class="nx">j</span><span class="p">]</span> <span class="p">=</span> <span class="nx">i</span> <span class="o">+</span> <span class="nx">j</span>
 </span></span><span class="line"><span class="cl">        <span class="p">}</span>
 </span></span><span class="line"><span class="cl">    <span class="p">}</span>
@@ -322,7 +322,7 @@ Go&rsquo;s other key builtin data structure: maps.</p>
     </div>
     <script>
       var codeLines = [];
-      codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A    \"fmt\"\u000A    \"slices\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push('    var s []string\u000A    fmt.Println(\"uninit:\", s, s \u003D\u003D nil, len(s) \u003D\u003D 0)\u000A');codeLines.push('    s \u003D make([]string, 3)\u000A    fmt.Println(\"emp:\", s, \"len:\", len(s), \"cap:\", cap(s))\u000A');codeLines.push('    s[0] \u003D \"a\"\u000A    s[1] \u003D \"b\"\u000A    s[2] \u003D \"c\"\u000A    fmt.Println(\"set:\", s)\u000A    fmt.Println(\"get:\", s[2])\u000A');codeLines.push('    fmt.Println(\"len:\", len(s))\u000A');codeLines.push('    s \u003D append(s, \"d\")\u000A    s \u003D append(s, \"e\", \"f\")\u000A    fmt.Println(\"apd:\", s)\u000A');codeLines.push('    c :\u003D make([]string, len(s))\u000A    copy(c, s)\u000A    fmt.Println(\"cpy:\", c)\u000A');codeLines.push('    l :\u003D s[2:5]\u000A    fmt.Println(\"sl1:\", l)\u000A');codeLines.push('    l \u003D s[:5]\u000A    fmt.Println(\"sl2:\", l)\u000A');codeLines.push('    l \u003D s[2:]\u000A    fmt.Println(\"sl3:\", l)\u000A');codeLines.push('    t :\u003D []string{\"g\", \"h\", \"i\"}\u000A    fmt.Println(\"dcl:\", t)\u000A');codeLines.push('    t2 :\u003D []string{\"g\", \"h\", \"i\"}\u000A    if slices.Equal(t, t2) {\u000A        fmt.Println(\"t \u003D\u003D t2\")\u000A    }\u000A');codeLines.push('    twoD :\u003D make([][]int, 3)\u000A    for i :\u003D 0; i \u003C 3; i++ {\u000A        innerLen :\u003D i + 1\u000A        twoD[i] \u003D make([]int, innerLen)\u000A        for j :\u003D 0; j \u003C innerLen; j++ {\u000A            twoD[i][j] \u003D i + j\u000A        }\u000A    }\u000A    fmt.Println(\"2d: \", twoD)\u000A}\u000A');codeLines.push('');codeLines.push('');codeLines.push('');
+      codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A    \"fmt\"\u000A    \"slices\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push('    var s []string\u000A    fmt.Println(\"uninit:\", s, s \u003D\u003D nil, len(s) \u003D\u003D 0)\u000A');codeLines.push('    s \u003D make([]string, 3)\u000A    fmt.Println(\"emp:\", s, \"len:\", len(s), \"cap:\", cap(s))\u000A');codeLines.push('    s[0] \u003D \"a\"\u000A    s[1] \u003D \"b\"\u000A    s[2] \u003D \"c\"\u000A    fmt.Println(\"set:\", s)\u000A    fmt.Println(\"get:\", s[2])\u000A');codeLines.push('    fmt.Println(\"len:\", len(s))\u000A');codeLines.push('    s \u003D append(s, \"d\")\u000A    s \u003D append(s, \"e\", \"f\")\u000A    fmt.Println(\"apd:\", s)\u000A');codeLines.push('    c :\u003D make([]string, len(s))\u000A    copy(c, s)\u000A    fmt.Println(\"cpy:\", c)\u000A');codeLines.push('    l :\u003D s[2:5]\u000A    fmt.Println(\"sl1:\", l)\u000A');codeLines.push('    l \u003D s[:5]\u000A    fmt.Println(\"sl2:\", l)\u000A');codeLines.push('    l \u003D s[2:]\u000A    fmt.Println(\"sl3:\", l)\u000A');codeLines.push('    t :\u003D []string{\"g\", \"h\", \"i\"}\u000A    fmt.Println(\"dcl:\", t)\u000A');codeLines.push('    t2 :\u003D []string{\"g\", \"h\", \"i\"}\u000A    if slices.Equal(t, t2) {\u000A        fmt.Println(\"t \u003D\u003D t2\")\u000A    }\u000A');codeLines.push('    twoD :\u003D make([][]int, 3)\u000A    for i :\u003D range 3 {\u000A        innerLen :\u003D i + 1\u000A        twoD[i] \u003D make([]int, innerLen)\u000A        for j :\u003D range innerLen {\u000A            twoD[i][j] \u003D i + j\u000A        }\u000A    }\u000A    fmt.Println(\"2d: \", twoD)\u000A}\u000A');codeLines.push('');codeLines.push('');codeLines.push('');
     </script>
     <script src="site.js" async></script>
   </body>

public/stateful-goroutines

@@ -51,7 +51,7 @@ by exactly 1 goroutine.</p>
             
           </td>
           <td class="code leading">
-            <a href="https://go.dev/play/p/TBcWd-OfnaA"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
+            <a href="https://go.dev/play/p/uX6AcrTXA-a"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
           <pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">main</span></span></span></code></pre>
           </td>
         </tr>
@@ -174,7 +174,7 @@ result over the provided <code>resp</code> channel.</p>
           </td>
           <td class="code leading">
             
-          <pre class="chroma"><code><span class="line"><span class="cl">    <span class="k">for</span> <span class="nx">r</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">r</span> <span class="p">&lt;</span> <span class="mi">100</span><span class="p">;</span> <span class="nx">r</span><span class="o">++</span> <span class="p">{</span>
+          <pre class="chroma"><code><span class="line"><span class="cl">    <span class="k">for</span> <span class="k">range</span> <span class="mi">100</span> <span class="p">{</span>
 </span></span><span class="line"><span class="cl">        <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
 </span></span><span class="line"><span class="cl">            <span class="k">for</span> <span class="p">{</span>
 </span></span><span class="line"><span class="cl">                <span class="nx">read</span> <span class="o">:=</span> <span class="nx">readOp</span><span class="p">{</span>
@@ -198,7 +198,7 @@ approach.</p>
           </td>
           <td class="code leading">
             
-          <pre class="chroma"><code><span class="line"><span class="cl">    <span class="k">for</span> <span class="nx">w</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">w</span> <span class="p">&lt;</span> <span class="mi">10</span><span class="p">;</span> <span class="nx">w</span><span class="o">++</span> <span class="p">{</span>
+          <pre class="chroma"><code><span class="line"><span class="cl">    <span class="k">for</span> <span class="k">range</span> <span class="mi">10</span> <span class="p">{</span>
 </span></span><span class="line"><span class="cl">        <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
 </span></span><span class="line"><span class="cl">            <span class="k">for</span> <span class="p">{</span>
 </span></span><span class="line"><span class="cl">                <span class="nx">write</span> <span class="o">:=</span> <span class="nx">writeOp</span><span class="p">{</span>
@@ -293,7 +293,7 @@ program.</p>
     </div>
     <script>
       var codeLines = [];
-      codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A    \"fmt\"\u000A    \"math/rand\"\u000A    \"sync/atomic\"\u000A    \"time\"\u000A)\u000A');codeLines.push('type readOp struct {\u000A    key  int\u000A    resp chan int\u000A}\u000Atype writeOp struct {\u000A    key  int\u000A    val  int\u000A    resp chan bool\u000A}\u000A');codeLines.push('func main() {\u000A');codeLines.push('    var readOps uint64\u000A    var writeOps uint64\u000A');codeLines.push('    reads :\u003D make(chan readOp)\u000A    writes :\u003D make(chan writeOp)\u000A');codeLines.push('    go func() {\u000A        var state \u003D make(map[int]int)\u000A        for {\u000A            select {\u000A            case read :\u003D \u003C-reads:\u000A                read.resp \u003C- state[read.key]\u000A            case write :\u003D \u003C-writes:\u000A                state[write.key] \u003D write.val\u000A                write.resp \u003C- true\u000A            }\u000A        }\u000A    }()\u000A');codeLines.push('    for r :\u003D 0; r \u003C 100; r++ {\u000A        go func() {\u000A            for {\u000A                read :\u003D readOp{\u000A                    key:  rand.Intn(5),\u000A                    resp: make(chan int)}\u000A                reads \u003C- read\u000A                \u003C-read.resp\u000A                atomic.AddUint64(\u0026readOps, 1)\u000A                time.Sleep(time.Millisecond)\u000A            }\u000A        }()\u000A    }\u000A');codeLines.push('    for w :\u003D 0; w \u003C 10; w++ {\u000A        go func() {\u000A            for {\u000A                write :\u003D writeOp{\u000A                    key:  rand.Intn(5),\u000A                    val:  rand.Intn(100),\u000A                    resp: make(chan bool)}\u000A                writes \u003C- write\u000A                \u003C-write.resp\u000A                atomic.AddUint64(\u0026writeOps, 1)\u000A                time.Sleep(time.Millisecond)\u000A            }\u000A        }()\u000A    }\u000A');codeLines.push('    time.Sleep(time.Second)\u000A');codeLines.push('    readOpsFinal :\u003D atomic.LoadUint64(\u0026readOps)\u000A    fmt.Println(\"readOps:\", readOpsFinal)\u000A    writeOpsFinal :\u003D atomic.LoadUint64(\u0026writeOps)\u000A    fmt.Println(\"writeOps:\", writeOpsFinal)\u000A}\u000A');codeLines.push('');codeLines.push('');
+      codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A    \"fmt\"\u000A    \"math/rand\"\u000A    \"sync/atomic\"\u000A    \"time\"\u000A)\u000A');codeLines.push('type readOp struct {\u000A    key  int\u000A    resp chan int\u000A}\u000Atype writeOp struct {\u000A    key  int\u000A    val  int\u000A    resp chan bool\u000A}\u000A');codeLines.push('func main() {\u000A');codeLines.push('    var readOps uint64\u000A    var writeOps uint64\u000A');codeLines.push('    reads :\u003D make(chan readOp)\u000A    writes :\u003D make(chan writeOp)\u000A');codeLines.push('    go func() {\u000A        var state \u003D make(map[int]int)\u000A        for {\u000A            select {\u000A            case read :\u003D \u003C-reads:\u000A                read.resp \u003C- state[read.key]\u000A            case write :\u003D \u003C-writes:\u000A                state[write.key] \u003D write.val\u000A                write.resp \u003C- true\u000A            }\u000A        }\u000A    }()\u000A');codeLines.push('    for range 100 {\u000A        go func() {\u000A            for {\u000A                read :\u003D readOp{\u000A                    key:  rand.Intn(5),\u000A                    resp: make(chan int)}\u000A                reads \u003C- read\u000A                \u003C-read.resp\u000A                atomic.AddUint64(\u0026readOps, 1)\u000A                time.Sleep(time.Millisecond)\u000A            }\u000A        }()\u000A    }\u000A');codeLines.push('    for range 10 {\u000A        go func() {\u000A            for {\u000A                write :\u003D writeOp{\u000A                    key:  rand.Intn(5),\u000A                    val:  rand.Intn(100),\u000A                    resp: make(chan bool)}\u000A                writes \u003C- write\u000A                \u003C-write.resp\u000A                atomic.AddUint64(\u0026writeOps, 1)\u000A                time.Sleep(time.Millisecond)\u000A            }\u000A        }()\u000A    }\u000A');codeLines.push('    time.Sleep(time.Second)\u000A');codeLines.push('    readOpsFinal :\u003D atomic.LoadUint64(\u0026readOps)\u000A    fmt.Println(\"readOps:\", readOpsFinal)\u000A    writeOpsFinal :\u003D atomic.LoadUint64(\u0026writeOps)\u000A    fmt.Println(\"writeOps:\", writeOpsFinal)\u000A}\u000A');codeLines.push('');codeLines.push('');
     </script>
     <script src="site.js" async></script>
   </body>

public/string-functions

@@ -46,7 +46,7 @@ to give you a sense of the package.</p>
             
           </td>
           <td class="code leading">
-            <a href="https://go.dev/play/p/DSKkoyx9Rcy"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
+            <a href="https://go.dev/play/p/wKSAzxfs96O"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
           <pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">main</span></span></span></code></pre>
           </td>
         </tr>
@@ -91,7 +91,7 @@ it a lot below.</p>
             <p>Here&rsquo;s a sample of the functions available in
 <code>strings</code>. Since these are functions from the
 package, not methods on the string object itself,
-we need pass the string in question as the first
+we need to pass the string in question as the first
 argument to the function. You can find more
 functions in the <a href="https://pkg.go.dev/strings"><code>strings</code></a>
 package docs.</p>

public/testing-and-benchmarking

@@ -50,7 +50,7 @@ typically lives in the same package as the code it tests.</p>
 
           </td>
           <td class="code leading">
-            <a href="https://go.dev/play/p/PlzU16wwEWE"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
+            <a href="https://go.dev/play/p/osZckbKSkse"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
           <pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">main</span></span></span></code></pre>
           </td>
         </tr>
@@ -143,7 +143,7 @@ walks over them and performs the test logic.</p>
         
         <tr>
           <td class="docs">
-            <p>t.Run enables running &ldquo;subtests&rdquo;, one for each
+            <p><code>t.Run</code> enables running &ldquo;subtests&rdquo;, one for each
 table entry. These are shown separately
 when executing <code>go test -v</code>.</p>
 
@@ -175,27 +175,28 @@ when executing <code>go test -v</code>.</p>
         <tr>
           <td class="docs">
             <p>Benchmark tests typically go in <code>_test.go</code> files and are
-named beginning with <code>Benchmark</code>. The <code>testing</code> runner
-executes each benchmark function several times, increasing
-<code>b.N</code> on each run until it collects a precise measurement.</p>
+named beginning with <code>Benchmark</code>.
+Any code that&rsquo;s required for the benchmark to run but should
+not be measured goes before this loop.</p>
 
           </td>
           <td class="code leading">
             
-          <pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">BenchmarkIntMin</span><span class="p">(</span><span class="nx">b</span> <span class="o">*</span><span class="nx">testing</span><span class="p">.</span><span class="nx">B</span><span class="p">)</span> <span class="p">{</span></span></span></code></pre>
+          <pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">BenchmarkIntMin</span><span class="p">(</span><span class="nx">b</span> <span class="o">*</span><span class="nx">testing</span><span class="p">.</span><span class="nx">B</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="nx">b</span><span class="p">.</span><span class="nf">Loop</span><span class="p">()</span> <span class="p">{</span></span></span></code></pre>
           </td>
         </tr>
         
         <tr>
           <td class="docs">
-            <p>Typically the benchmark runs a function we&rsquo;re
-benchmarking in a loop <code>b.N</code> times.</p>
+            <p>The benchmark runner will automatically execute this loop
+body many times to determine a reasonable estimate of the
+run-time of a single iteration.</p>
 
           </td>
           <td class="code">
             
-          <pre class="chroma"><code><span class="line"><span class="cl">    <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="p">&lt;</span> <span class="nx">b</span><span class="p">.</span><span class="nx">N</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">{</span>
-</span></span><span class="line"><span class="cl">        <span class="nf">IntMin</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
+          <pre class="chroma"><code><span class="line"><span class="cl">        <span class="nf">IntMin</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
 </span></span><span class="line"><span class="cl">    <span class="p">}</span>
 </span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre>
           </td>
@@ -266,7 +267,7 @@ benchmark function names with a regexp.</p>
     </div>
     <script>
       var codeLines = [];
-      codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A    \"fmt\"\u000A    \"testing\"\u000A)\u000A');codeLines.push('func IntMin(a, b int) int {\u000A    if a \u003C b {\u000A        return a\u000A    }\u000A    return b\u000A}\u000A');codeLines.push('func TestIntMinBasic(t *testing.T) {\u000A    ans :\u003D IntMin(2, -2)\u000A    if ans !\u003D -2 {\u000A');codeLines.push('        t.Errorf(\"IntMin(2, -2) \u003D %d; want -2\", ans)\u000A    }\u000A}\u000A');codeLines.push('func TestIntMinTableDriven(t *testing.T) {\u000A    var tests \u003D []struct {\u000A        a, b int\u000A        want int\u000A    }{\u000A        {0, 1, 0},\u000A        {1, 0, 0},\u000A        {2, -2, -2},\u000A        {0, -1, -1},\u000A        {-1, 0, -1},\u000A    }\u000A');codeLines.push('    for _, tt :\u003D range tests {\u000A');codeLines.push('        testname :\u003D fmt.Sprintf(\"%d,%d\", tt.a, tt.b)\u000A        t.Run(testname, func(t *testing.T) {\u000A            ans :\u003D IntMin(tt.a, tt.b)\u000A            if ans !\u003D tt.want {\u000A                t.Errorf(\"got %d, want %d\", ans, tt.want)\u000A            }\u000A        })\u000A    }\u000A}\u000A');codeLines.push('func BenchmarkIntMin(b *testing.B) {\u000A');codeLines.push('    for i :\u003D 0; i \u003C b.N; i++ {\u000A        IntMin(1, 2)\u000A    }\u000A}\u000A');codeLines.push('');codeLines.push('');
+      codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A    \"fmt\"\u000A    \"testing\"\u000A)\u000A');codeLines.push('func IntMin(a, b int) int {\u000A    if a \u003C b {\u000A        return a\u000A    }\u000A    return b\u000A}\u000A');codeLines.push('func TestIntMinBasic(t *testing.T) {\u000A    ans :\u003D IntMin(2, -2)\u000A    if ans !\u003D -2 {\u000A');codeLines.push('        t.Errorf(\"IntMin(2, -2) \u003D %d; want -2\", ans)\u000A    }\u000A}\u000A');codeLines.push('func TestIntMinTableDriven(t *testing.T) {\u000A    var tests \u003D []struct {\u000A        a, b int\u000A        want int\u000A    }{\u000A        {0, 1, 0},\u000A        {1, 0, 0},\u000A        {2, -2, -2},\u000A        {0, -1, -1},\u000A        {-1, 0, -1},\u000A    }\u000A');codeLines.push('    for _, tt :\u003D range tests {\u000A');codeLines.push('        testname :\u003D fmt.Sprintf(\"%d,%d\", tt.a, tt.b)\u000A        t.Run(testname, func(t *testing.T) {\u000A            ans :\u003D IntMin(tt.a, tt.b)\u000A            if ans !\u003D tt.want {\u000A                t.Errorf(\"got %d, want %d\", ans, tt.want)\u000A            }\u000A        })\u000A    }\u000A}\u000A');codeLines.push('func BenchmarkIntMin(b *testing.B) {\u000A    for b.Loop() {\u000A');codeLines.push('        IntMin(1, 2)\u000A    }\u000A}\u000A');codeLines.push('');codeLines.push('');
     </script>
     <script src="site.js" async></script>
   </body>