In Go what is the best way to convert an array of string types to an array of string

The following code

package main

import "strings"
import "fmt"

type Foo string

const (
	Bar    Foo = "bar"
	Snafu      = "snafu"
	Foobar     = "foobar"
)

var Foos = []Foo{Bar, Snafu, Foobar}

func main() {
	fmt.Println("Foos: " + strings.Join(Foos, ","))
}

Produces this error:

./test.go:17: cannot use Foos (type []Foo) as type []string in argument to strings.Join

This makes sense since Foo is not string but it is derived from string. Is there any way to coerce the "[]Foo" to "[]string" without copying?

Pretty much the best and only way to do it is to loop over the slice of Foo objects as in (causing a copy):

func main() {
    results := make([]string, 0, len(Foos))
    for _, r := range Foos{
       results = append(results, string(r))
    }
    fmt.Println("Foos: " + strings.Join(results, ","))
}

Unfortunately as of this time Go does not support the concept type coercion and requires a copy. As an alternative you can type alias []Foo and add a Stringer method to it therefore encapsulating such details as in: http://play.golang.org/p/FuOoLNrCvD

See the following for a similar question: https://stackoverflow.com/questions/12990338/cannot-convert-string-to-interface

You can use https://github.com/ledongthuc/goterators#map that I created to reuse aggregate & transforms functions.

package main

import (
	"fmt"
	"strings"

	"github.com/ledongthuc/goterators"
)

type Foo string

const (
	Bar    Foo = "bar"
	Snafu      = "snafu"
	Foobar     = "foobar"
)

var Foos = []Foo{Bar, Snafu, Foobar}

func main() {
	strs := goterators.Map(Foos, func(item Foo) string {
		return string(item)
	})
	fmt.Println("Foos: " + strings.Join(strs, ","))
}

Or if you want an optimized way, you can use Reduce

package main

import (
	"fmt"

	"github.com/ledongthuc/goterators"
)

type Foo string

const (
	Bar    Foo = "bar"
	Snafu      = "snafu"
	Foobar     = "foobar"
)

var Foos = []Foo{Bar, Snafu, Foobar}

func main() {
	joinStr := goterators.Reduce(Foos, "", func(previous string, current Foo, index int, list []Foo) string {
		if len(previous) == 0 {
			return string(current)
		}
		return previous + "," + string(current)
	})
	fmt.Println("Foos: " + joinStr)
}

They are required go 1.18 to use that support generic + dynamic type you want to use with.