Call Go function that accepts a slice of interface A with a slice of struct B (B implements A)
go, interface, types
Solution
The in-memory layout of a `[]Quote` slice is different to a `[]Statement` slice, so this is not possible.
The backing array of the `[]Quote` slice will consist of the sequential `Quote` structs, while the `[]Statement` slice's backing array consists of interface variables. As well as holding the `Quote` struct (or whatever other type implements the interface), the interface variable also stores a pointer to type information for the contained value. This is needed to determine how to dispatch the `Say` method call.
The different data layout means that you can't interchange the two slice types, not even through unsafe casts: if you have one type and need the other you'll need to manually convert between them.
Problem
I have the following types: ``` type Statement interface { Say() string } type Quote struct { quote string } func (p Quote) Say() string { return p.quote } func Replay(conversation []Statement) { for _, statement := range conversation { fmt.Println(statement.Say()) } } ``` I think I have a fairly good grasp of why a function that accepts a parameter of type `[]Statement`, cannot be called with `[]Quote`; even though `Quote` implements `Statement`, `[]Quote` does not implement `[]Statement`. `[]Statement` is not even an interface. It has the type `slice of Statement`. While Go implicitly converts from a type to an interface type, it does no implicit conversion from a slice of type `A` to a slice of interface `B`. We can convert the quotes to statements explicitly: ``` conversation := []Quote{ Quote{"Nice Guy Eddie: C'mon, throw in a buck!"}, Quote{"Mr. Pink: Uh-uh, I don't tip."}, Quote{"Nice Guy Eddie: You don't tip?"}, Quote{"Mr. Pink: Nah, I don't believe in it."}, Quote{"Nice Guy Eddie: You don't believe in tipping?"}, } // This doesn't work // Replay(conversation) // Create statements from quotes statements := make([]Statement, len(conversation)) for i, quote := range conversation { statements[i] = quote } Replay(statements) ``` Now say that Replay is part of a library that wants to go out of its way in how easy it's to use Replay. It allows you to call Replay with any slice of objects as long as those objects implement the Statement interface. To do so it has the following conversion method: ``` func ConvertToStatements(its interface{}) ([]Statement, error) { itsValue := reflect.ValueOf(its) itsKind := itsValue.Kind() if itsKind != reflect.Array && itsKind != reflect.Slice { return nil, fmt.Errorf("Expected items to be an Array or a Slice, got %s", itsKind) } itsLength := itsValue.Len() items := make([]Statement, itsLength) for i := 0; i < itsLength; i++ { itsItem := itsValue.Index(i) if item, ok := itsItem.Interface().(Statement); ok { items[i] = item } else { return nil, fmt.Errorf("item #%d does not implement the Statement interface: %s", i, itsItem) } } return items, nil } ``` Replay looks like this: ``` func Replay(its interface{}) { conversation := ConvertToStatements(its) for _, statement := range conversation { fmt.Println(statement.Say()) } } ``` We can now call Replay with quotes directly: ``` Replay(conversation) ``` Finally, my question: Is there a simpler way to allow Replay to accept a slice of any type A, as long as A implements the Statement interface?