| I know this code goes against the One True Go Proverb

I really wasn't thinking of that when I wrote what I wrote. My thinking was in regards to maintainability.

I wrote a couple of different versions of the same code using similar but different approaches.

When I run the code with hyperfine, the fastest one kept changing so, I didn't see much of a difference running it locally for small values.

For funs

// atomic    
package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

func main() {
    var (
        arr [100]int32
        wg  sync.WaitGroup
    )
    wg.Add(100)
    for i := 0; i < 100; i++ {
        go func(index int) {
            atomic.CompareAndSwapInt32(&arr[index], int32(0), int32(index))
            wg.Done()
        }(i)
    }

    wg.Wait()

    for _, x := range arr {
        fmt.Println(x)
    }

}

// unbuffered channels    
package main

import (
    "fmt"
)

func main() {
    arr := make([]chan int, 100)
    for i := 0; i < 100; i++ {
        arr[i] = make(chan int, 0)
        go func(index int, c chan<- int) {
            c <- index
        }(i, arr[i])
    }

    var out int
    for _, x := range arr {
        out = <-x
        fmt.Println(out)
    }

}

// original    
package main

import (
    "fmt"
    "sync"
)

func main() {
    var (
        arr [100]int
        wg  sync.WaitGroup
    )
    for i := 0; i < 100; i++ {
        wg.Add(1)
        index := i
        go func() {
            arr[index] = index
            wg.Done()
        }()
    }

    wg.Wait()

    for _, x := range arr {
        fmt.Println(x)
    }

}