Why Can't You Convert Slice Types?

The inability to convert slices of different types, as exemplified by the code snippet provided, is due to specific type conversion rules outlined in the Go specification. These rules govern when a non-constant value can be converted to a specific type.

None of the conversion rules apply to the case where you attempt to convert a slice of Bar to a slice of Foo. While the underlying types of Foo and Bar are identical, the underlying types of their respective slices are not. This results in the inability to assign a []Foo value to a variable of type []Bar.

Understanding the Underlying Types

It's crucial to note that the underlying type of a variable is not necessarily the same as the type of the variable itself. In the case of slices, the element type is the underlying type. Thus, while Foo and Bar have the same underlying type (Foo), []Foo and []Bar do not.

A Practical Solution

To address this issue, you can create an intermediate type that aliases Bar as Foo. This approach works because the element type of the slice remains the same. For example:

type Foo struct { A int }
type Bar Foo

type Foos []Foo
type Bars Foos

func main() {
    foos := []Foo{Foo{1}, Foo{2}}
    bars := Bars(foos)

    fmt.Println(bars)
}

Output:

[{1} {2}]

This solution creates slices with the same underlying element type, allowing for the conversion between them.

Unsafe Considerations

As a note of caution, while it's technically possible to "view" a slice of Foo as a slice of Bar using unsafe operations, this approach circumvents type safety. It's recommended to use the type aliasing approach outlined above for safety and reliability.