Por que você não consegue converter tipos de fatia?

A incapacidade de converter fatias de tipos diferentes, conforme exemplificado pelo snippet de código fornecido, é devido à conversão de tipo específico regras descritas na especificação Go. Essas regras determinam quando um valor não constante pode ser convertido em um tipo específico.

Nenhuma das regras de conversão se aplica ao caso em que você tenta converter uma fatia de Bar em uma fatia de Foo. Embora os tipos subjacentes de Foo e Bar sejam idênticos, os tipos subjacentes de suas respectivas fatias não o são. Isso resulta na incapacidade de atribuir um valor []Foo a uma variável do tipo []Bar.

Compreendendo os tipos subjacentes

É crucial observar que o valor subjacente O tipo de uma variável não é necessariamente igual ao tipo da própria variável. No caso de fatias, o tipo de elemento é o tipo subjacente. Assim, embora Foo e Bar tenham o mesmo tipo subjacente (Foo), []Foo e []Bar não.

Uma solução prática

Para resolver esse problema , você pode criar um tipo intermediário que alia Bar como Foo. Essa abordagem funciona porque o tipo de elemento da fatia permanece o mesmo. Por exemplo:

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

Saída:

[{1} {2}]

Esta solução cria fatias com o mesmo tipo de elemento subjacente, permitindo a conversão entre elas.

Considerações inseguras

Como nota de cautela, embora seja tecnicamente possível "visualizar" uma fatia de Foo como uma fatia de Bar usando operações inseguras, esta abordagem contorna a segurança de tipo. É recomendado usar a abordagem de alias de tipo descrita acima para segurança e confiabilidade.