Conversion de tranches d'interfaces en tranches d'interface compatibles

La mise en œuvre de différentes interfaces contenant des méthodes qui se chevauchent peut offrir une flexibilité de programmation. Cependant, transmettre une tranche d’une interface à une fonction attendant une interface différente mais compatible peut entraîner des erreurs. Voyons comment résoudre ce problème dans Go.

Supposons que nous ayons les interfaces A et B, où A inclut B. Une implémentation de A, Impl, satisfait à la fois A et 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
}

Les éléments individuels peuvent être facilement transmis d'une fonction à l'autre. Cependant, tenter de transmettre des tranches de A aux fonctions attendant io.Reader peut échouer.

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)

Pour résoudre ce problème, nous pouvons créer une nouvelle tranche de type []io.Reader et la remplir avec des éléments de []A. Il s'agit d'une solution de contournement permettant de contourner la limitation et d'assurer la compatibilité entre des types d'interface différents mais qui se chevauchent.