Convertendo fatias de interfaces em fatias de interface compatíveis

A implementação de diferentes interfaces que contêm métodos sobrepostos pode fornecer flexibilidade na programação. No entanto, passar uma fatia de uma interface para uma função que espera uma interface diferente, mas compatível, pode resultar em erros. Vamos explorar como resolver esse problema em Go.

Suponha que temos interfaces A e B, onde A inclui B. Uma implementação de A, Impl, satisfaz A e B.

type A interface {
    Close() error
    Read(b []byte) (int, error)
}

type Impl struct {}

func (I Impl) Read(b []byte) (int, error) {
    fmt.Println("In read!")
    return 10, nil
}

func (I Impl) Close() error {
    fmt.Println("I am here!")
    return nil
}

Itens individuais podem ser passados ​​entre funções com facilidade. No entanto, a tentativa de passar fatias de A para funções que esperam io.Reader pode falhar.

func single(r io.Reader) {
    fmt.Println("in single")
}

func slice(r []io.Reader) {
    fmt.Println("in slice")
}

im := &Impl{}

// works
single(im)

// FAILS!
list := []A{t}
slice(list)

Para resolver isso, podemos criar uma nova fatia do tipo []io.Reader e preenchê-la com elementos de []A. Esta é a solução alternativa para contornar a limitação e garantir a compatibilidade entre tipos de interface diferentes, mas sobrepostos.