Golang：在字符串的类型别名上使用string.join

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, ","))
}

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

Here's a solution using the unsafe package:

func MergeScopes(scopes ...SpecialScopes) SpecialScopes {
    specialScopes := *(*[]string)((unsafe.Pointer(&scopes)))
    s := strings.Join(specialScopes, ",")
    return *(*SpecialScopes)((unsafe.Pointer(&s)))
}

https://play.golang.org/p/-wsHY2eCdc

If you really want something fast, this is the faster way in Go:

func MergeScopes(scopes ...SpecialScopes) SpecialScopes {
    var buffer bytes.Buffer
    for ix, s := range scopes {
        buffer.WriteString(string(s))
        if ix < len(scopes)-1 {
            buffer.WriteString(", ")    
        }
    }

    return SpecialScopes(buffer.String())
}

Full example: https://play.golang.org/p/McWjh1yxHf

I know it doesn't look nice like a simple .Join() but it's easy to read.