Q:

Golang: Use string.join on a type alias for a string

I have a type alias for string like 
type SpecialScopes string
and I want to Join an array of this type using the strings.Join function
func MergeScopes(scopes ...SpecialScopes) SpecialScopes {
    return strings.Join(scopes, ",")
}

But with the above I get the errors
cannot use scopes (type []SpecialScopes) as type []string in argument to strings.Join
cannot use strings.Join(scopes, ",") (type string) as type SpecialScopes in return argument

Is there a way to make golang realize that SpecialScopes is just another name for strings and do the join function on it?
If not what is the most efficient way to go about doing this? One way I see is to cast all the elements in the array to string, join, then cast it back to SpecialScopes and return the value
Update 1:
I have a working implementation that casts the values. Any suggestions for a faster way to do this?
func MergeScopes(scopes ...SpecialScopes) SpecialScopes {
    var s []string
    for _, scope := range scopes {
        s = append(s, string(scope))
    }

    return SpecialScopes(strings.Join(s, ","))
}

A:

This is mostly the fastest way without using unsafe.
func MergeScopes(scopes ...SpecialScopes) SpecialScopes {
    if len(scopes) == 0 {
        return ""
    }
    var (
        sep = []byte(", ")
        // preallocate for len(sep) + assume at least 1 character
        out = make([]byte, 0, (1+len(sep))*len(scopes))
    )
    for _, s := range scopes {
        out = append(out, s...)
        out = append(out, sep...)
    }
    return SpecialScopes(out[:len(out)-len(sep)])
}

Benchmark code: https://play.golang.org/p/DrB8nM-6ws
━➤ go test -benchmem -bench=.  -v -benchtime=2s
testing: warning: no tests to run
BenchmarkUnsafe-8       30000000               109 ns/op              32 B/op          2 allocs/op
BenchmarkBuffer-8       20000000               255 ns/op             128 B/op          2 allocs/op
BenchmarkCopy-8         10000000               233 ns/op             112 B/op          3 allocs/op
BenchmarkConcat-8       30000000               112 ns/op              32 B/op          2 allocs/op

