Sens d'une struct avec embedded anonyme interface?

Ok, accepté la réponse m'a aidé à comprendre, mais j'ai décidé de poster une explication qui, je pense, convient mieux à ma façon de penser.

La "Efficace Go" a l'exemple des interfaces intégrées à d'autres interfaces:

//ReadWriter is the interface that combines the Reader and Writer interfaces.
type ReadWriter interface {
    Reader
    Writer
}

et une structure ayant incorporé d'autres structures:

//ReadWriter stores pointers to a Reader and a Writer.
//It implements io.ReadWriter.
type ReadWriter struct {
    *Reader  //*bufio.Reader
    *Writer  //*bufio.Writer
}

Mais il n'est fait mention d'une structure ayant intégré une interface. J'étais confus de voir cela dans sort package:

type Interface interface {
    Len() int
    Less(i, j int) bool
    Swap(i, j int)
}

...

type reverse struct {
    Interface
}

Mais l'idée est simple. C'est presque la même chose que:

type reverse struct {
    IntSlice  //IntSlice struct attaches the methods of Interface to []int, sorting in increasing order
}

méthodes de IntSlice d'être promu reverse.

Et ce:

type reverse struct {
    Interface
}

signifie que sort.reverse peut intégrer n'importe quel struct qui implémente l'interface sort.Interface et quelles que soient les méthodes de l'interface, ils seront promus à reverse.

sort.Interface a la méthode Less(i, j int) bool qui peut maintenant être remplacée:

//Less returns the opposite of the embedded implementation's Less method.
func (r reverse) Less(i, j int) bool {
        return r.Interface.Less(j, i)
}

---

Ma confusion dans la compréhension de

type reverse struct {
    Interface
}

est que je pensais qu'une struct a toujours une structure fixe, c'est à dire le nombre fixe de champs fixes.

Mais la suite prouve que j'ai tort:

package main

import "fmt"

//some interface
type Stringer interface {
    String() string
}

//a struct that implements Stringer interface
type Struct1 struct {
    field1 string
}

func (s Struct1) String() string {
    return s.field1
}


//another struct that implements Stringer interface, but has a different set of fields
type Struct2 struct {
    field1 []string
    dummy bool
}

func (s Struct2) String() string {
    return fmt.Sprintf("%v, %v", s.field1, s.dummy)
}


//container that can embedd any struct which implements Stringer interface
type StringerContainer struct {
    Stringer
}


func main() {
    //the following prints: This is Struct1
    fmt.Println(StringerContainer{Struct1{"This is Struct1"}})
    //the following prints: [This is Struct1], true
    fmt.Println(StringerContainer{Struct2{[]string{"This", "is", "Struct1"}, true}})
    //the following does not compile:
    //cannot use "This is a type that does not implement Stringer" (type string)
    //as type Stringer in field value:
    //string does not implement Stringer (missing String method)
    fmt.Println(StringerContainer{"This is a type that does not implement Stringer"})
}

Je vais donner mon explication trop. Le sort package définit un désexporter type reverse, qui est une structure, qui intègre Interface.

type reverse struct {
        //This embedded Interface permits Reverse to use the methods of
        //another Interface implementation.
        Interface
}

Ceci permet à l'Inverse de l'utilisation des méthodes d'un autre implémentation de l'Interface. C'est le composition, qui est une fonctionnalité puissante de Go.

La Less méthode pour reverse appelle la Less méthode de l'embedded Interface valeur, mais avec les indices retourner, inverser l'ordre de tri des résultats.

//Less returns the opposite of the embedded implementation's Less method.
func (r reverse) Less(i, j int) bool {
        return r.Interface.Less(j, i)
}

Len et Swap les deux autres méthodes de reverse, sont fournies de manière implicite par l'original Interface valeur, car il est encastré un champ. Le exporté Reverse fonction retourne une instance de la reverse type qui contient l'original Interface valeur.

//Reverse returns the reverse order for data.
func Reverse(data Interface) Interface {
        return &reverse{data}
}