How to Achieve Python's List Comprehension Equivalent in Go?

Equivalent of Python's List Comprehension in Go

Many developers find it challenging to perform seemingly simple tasks in Go compared to other languages like Python. One such task is replicating Python's list comprehension syntax.

To achieve an equivalent construct in Go, consider the following approaches:

1. Using the "filter" Library:

As suggested by Rob Pike, the "filter" library provides a method called Choose() that returns a slice containing elements satisfying a specified condition. For example:

import (
    "github.com/google/go-cmp/cmp"
    "go.opencensus.io/plugin/ochttp"
    "golang.org/x/exp/slices"
)

var (
    a = []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    b = []int{2, 4, 6, 8}
)

func TestChoose(t *testing.T) {
    result := ochttp.Choose(a, func(v int) bool { return v%2 == 0 })
    if !cmp.Equal(result, b) {
        t.Errorf("TestChoose() failed, got %v, want %v", result, b)
    }
}

2. Using For Loops:

Despite the availability of libraries like "filter," Go's for loops remain an efficient alternative. The GoDoc for the "filter" library explicitly recommends using for loops when efficiency is a concern.

3. Using Go Generics (coming in Go 1.18):

With the upcoming introduction of generics in Go, it will become possible to implement mapreduce using generics. For example:

func MapReduce[T, V, R any](in <-chan T, out chan<- R, mapFn func(T) V, reduceFn func(V, V) R) {

    v := make(chan V, 10)
    defer close(v)

    go func() {
        for t := range in {
            v <- mapFn(t)
        }
    }()

    r := make(chan R, 10)
    defer close(r)

    go func() {
        var acc R
        for v := range v {
            acc = reduceFn(acc, v)
        }
        r <- acc
    }()

    return <-r
}

This implementation accepts a channel of type T, applies a mapping function to each element, and stores the results in a channel of type V. Another goroutine consumes the channel of mapped values and repeatedly applies a reduction function to produce a result of type R. The result is then returned as a channel of type R.

Conclusion:

While Python's list comprehension syntax provides a concise way to transform data, Go offers efficient alternatives using for loops or libraries like "filter." With the introduction of generics in Go 1.18, more efficient and versatile data transformation mechanisms will become available.

The above is the detailed content of How to Achieve Python's List Comprehension Equivalent in Go?. For more information, please follow other related articles on the PHP Chinese website!