How to concatenate Aliased Types (of consts) into strings.Join()

I have an package/API that allows for passing in a slice of values. For example:

type ConstType string

const (
	T_Option1 ConstType = "OPTION-1"
	T_Option2 ConstType = "OPTION-2"
	T_Option3 ConstType = "OPTION-3"
)

Notice how this type is an alias of string.

Where I am running into a what-i-think-is-non-idomatic-step is that I can't cast or infer a slice of this type alias to a []string slice.

type constTypes struct {
	types []ConstType
}

func (s *constTypes) SetConstTypes(types []ConstType) {
	s.types = types
}

func (s *constTypes) String() string {

	// this generates a compile error because []ConstType is not
	// and []string.
	//
	// but, as you can see, ConstType is of type string
	//
	return strings.Join(s.types, ",")
}

I put this together in the playground to show a complete example:

http://play.golang.org/p/QMZ9DR5TVR

I know the Go solution is to cast it to the type (explicit Type casting, love the rule!). I just can't figure out how to cast a slice of types to []string - without looping through the collection.

One of the reasons I like Go is the enforcement of type casting, like:

c := T_OPTION1
v := string(c)
fmt.Println(v)

Play: http://play.golang.org/p/839Qp2jmIz

Though, I am unsure how to do this across the slice without looping. Must I loop?

Given, looping through the collection is not a big deal since there will only be 5 to 7 options max set. But still, I feel there should be a cast-able way to do this.

As @Not_a_Golfer points out, you should really be looping through the slice of constType and building up a new slice of string. This has the disadvantage of copying each element (which may or may not matter to you).

There is another solution, although it involves the unsafe package from the standard library. I've modified the example that you posted to the Go Playground (new link is http://play.golang.org/p/aLmvSraktF)

package main

import (
    "fmt"
    "strings"
    "unsafe"
)

type ConstType string

const (
    T_Option1 ConstType = "OPTION-1"
    T_Option2 ConstType = "OPTION-2"
    T_Option3 ConstType = "OPTION-3"
)

// constTypes is an internal/private member handling
type constTypes struct {
    types []ConstType
}

func (s *constTypes) SetConstTypes(types []ConstType) {
    s.types = types
}

func (s *constTypes) String() string {

    // Convert s.types to a string slice.
    var stringTypes []string // Long varibale declaration style so that you can see the type of stringTypes.
    stringTypes = *(*[]string)(unsafe.Pointer(&s.types))

    // Now you can use the strings package.
    return strings.Join(stringTypes, ",")
}

func main() {

    types := constTypes{}

    // a public method on my package's api allows this to be set via a slice:
    types.SetConstTypes([]ConstType{T_Option1, T_Option2, T_Option3})

    fmt.Println(types.String())
}